skLambda by eult 
skLambda is a Skript addon that adds lambda functions and listeners to Skript.
Events
0
Expressions
24
Effects
8
Conditions
3
Types
3
Sections
4
Structures
0
Total
44
skLambda by eult
1.3.0 9 days, 17 hours and 12 minutes ago
skLambda 1.3.0
Supports: Paper 1.21.1+ · Skript 2.15+
This release is about async. A lambda can run off the main thread, a trigger can wait for something without freezing the server, and a new watcher polls values and conditions for you so you don't have to write a loop.
New sections
- Wait for a future:
wait for %future% [within %timespan%]: suspends the trigger until the future resolves, then runs the body, where
result of %future% is ready to read. The server keeps ticking while it waits, it doesn't block. Use
wait for all of %futures% to join several (when-all) or
wait for any of %futures% for the first to finish. An optional
on timeout: block runs instead if the time runs out, and locals from either branch carry on to the code after the block.
- Wait for the next event:
wait for next <event> [where <condition>] [within %timespan%]: pauses a trigger until that event fires, with the event's values in scope in the body (so
message works for
chat). Filter with a trailing
where, cap the wait with
within, and handle the no-show with
on timeout:. The event has already dispatched by the time the body runs, so you can't cancel or change it there.
- Watch a value:
watch %value% every %timespan%: re-reads the expression on a timer and runs
on change: only when it differs from last time, with
old value and
new value in scope. Pass
within %timespan% for an
on timeout:, add
on end: for teardown, and tie it to an
owner: so it stops itself when the owner goes away. It's a normal listener, so
pause,
resume,
unregister and
/sklambda listeners all work on it.
- Watch a condition:
watch when <condition> every %timespan%: is edge-triggered.
on rising: fires the moment the condition goes false to true,
on falling: fires on true to false. The state at the first poll is the baseline, so a condition that's already true won't fire
on rising until it goes false and back. This is "do X the first time Y becomes true" without a poll loop.
New expressions
- Future of a lambda:
future of calling lambda %lambda% [with %objects%] starts the lambda on a background thread right away and hands you a future for its result. The body must be pure computation or I/O with no Bukkit API (no blocks, entities, inventories, or players), since touching the server off-thread will throw. Arguments are read on the main thread before it starts.
- New future:
a new future is an empty promise you resolve yourself later with
complete. Good for bridging a callback or another thread back into a waiting trigger.
- Future result:
result of %future% is the resolved value, or nothing for a future that isn't done yet or that failed. Read it after a
wait for, when the future is guaranteed resolved.
- Old and new value:
old value and
new value hold the previous and current readings inside a watcher's
on change: block.
New condition
- Future state:
%future% is done (also
resolved or
completed),
%future% is pending, and
%future% has failed, each with a negated form. Check a future before reading its result, or branch on whether a background job blew up.
New effect
- Complete a future:
complete %future% with %object% resolves one or more futures with a value and wakes any trigger waiting on them.
complete %future% with no value resolves it with nothing. A future that's already resolved is left alone.
1.2.0 17 days, 22 hours and 36 minutes ago
I've decided to keep working on skLambda, so I'm maintaining the project again. Here's 1.2.0.
skLambda 1.2.0
Supports: Paper 1.21.1+ · Skript 2.15+
New expressions
- Scanned (
%objects% scanned with %lambda%): like
reduced, but keeps every running result instead of only the last one. Give it
3, 5, 2 and an adding lambda and you get
3, 8, 10. Add
from %value% to start from a seed, which comes out first, so
3, 5, 2 from 100 gives
100, 103, 108, 110. Handy for running balances and cumulative totals.
- Zipped (
%objects% zipped with %objects% using %lambda%): walks two lists side by side and combines each pair with a two-argument lambda.
(1, 2, 3) zipped with
(10, 20, 30) and an adding lambda gives
11, 22, 33. It stops at the shorter list.
- Piped (
pipe %object% through %lambdas%): runs a value through a chain of one-argument lambdas, left to right, feeding each result into the next one.
pipe 5 through {_inc}, {_double} is the same as calling double on the result of inc. Anything in the list that isn't a lambda is skipped.
- Page / Window (
page N of %objects% by S): cuts a list into chunks of S and hands you the Nth one (1-based). The last page can be shorter, and a page past the end is empty.
window N of %objects% by S slides one element at a time instead, so window 1 is items 1 to S and window 2 is items 2 to S+1. Good for paging a list into a GUI.
- Page count / Window count (
page count of %objects% by S): how many pages the list splits into, rounded up so a partial last page still counts.
window count of %objects% by S is
length - S + 1. Loop over the count to fill a menu.
- Listener cooldown (
cooldown of %listener% or
%listener%'s cooldown): reads the
cooldown: you set on a listener, and you can change it from outside with set, add, and remove. Set it to zero to turn the cooldown off.
- Listener owner (
owner of %listener% or
%listener%'s owner): gives back the owner you tied a listener to with
owner:, or nothing if it has none.
New conditions
- Counting quantifiers (
at least N of,
at most N of,
exactly N of %objects% passes): check how many predicates in a list pass, not just all of them or none.
if at least 2 of {requirements::*} passes for {_p}: is true when two or more hold. They sit right next to the existing
all of /
any of /
none of forms.
New effect
- Pause / resume by owner (
pause all listeners owned by %object%): freezes every listener tied to that owner in one line, and
resume all listeners owned by %object% brings them back. Same idea as
unregister all listeners owned by, except it only pauses instead of stopping them for good.
Improvements
- Default parameters: a lambda parameter can carry a default,
lambda (n: number = 1) -> number:. When the caller leaves that argument off, the default fills in. Only trailing arguments can be skipped, so
call {_f} with 10 on a two-parameter lambda uses the default for the second one.
- Options work inside listen entries: script
options: like
{@grace} now expand inside a
listen section, so you can write
countdown: {@grace} or
cooldown: {@debounce} and reuse one value across listeners. They used to be left as raw text and fail to parse.
1.1.1 21 days, 8 hours and 54 minutes ago
This addon is no longer maintained. As of 1.1.1, skLambda will not receive further updates. The source stays available, but there are no planned releases, fixes, or support going forward. Feel free to fork it.
skLambda 1.1.1
Supports: Paper 1.21.1+ · Skript 2.15+
Removed
- Duplicate list expressions:
%objects% filtered where %objects% passes,
count of %objects% where %objects% passes, and
first of %objects% where %objects% passes have been removed. Skript core already ships its own
filtered, count, and first list operations, so these were redundant and only added overlap. The lambda forms (
filtered,
count of … where, and the
%lambda%-based expressions) still work as before.
Improvements
- Listener internals cleaned up: listener tracking, owner cleanup, and the active-listener registry were pulled out of one large class into focused pieces. No behavior change, just easier to maintain.
1.1.0 21 days, 16 hours and 30 minutes ago
skLambda 1.1.0
Supports: Paper 1.21.1+ · Skript 2.15+
New expressions
- Highest / Lowest By:
highest of %objects% by %lambda% and
lowest of %objects% by %lambda% give you back the one item with the biggest or smallest value. You write a small lambda that scores each item, and it hands you the winning item itself. Ties keep the first one; an empty list gives nothing. You can also say
min or
max.
- Bound:
%lambda% with %objects% bound fills in the first argument(s) ahead of time. An "add two numbers" lambda can become "add 5 to whatever you give me." Fill in every argument and you get a lambda that takes nothing and just returns the answer.
- Negated:
negated %lambda% (or
negation of %lambda%) flips a yes/no check so it passes when the original would fail. Handy with
filtered where and
count of … where.
- Active Listeners:
all active listeners gives you every listener running right now (the same ones
/sklambda listeners shows).
listeners owned by %object% gives you just the ones tied to one owner. You can loop over them and shut them down.
New listener options
- on register:: runs once, right when the listener starts up. It's the partner to
on end:, so you can set things up and clean them up in one place.
Improvements
- One-line lambdas can return a value: before, a one-line lambda could only check something or do something. Now it can also give back a value,
lambda (a, b): return {_a} + {_b}, or even shorter,
lambda (n): {_n} * 2.
- Lambdas remember nearby variables: a lambda keeps a copy of the local variables (
{_x}) from where you wrote it, so it can still read them when it runs later. It's a snapshot from that moment, changing those variables afterward won't affect it, and changes inside won't leak out. If a parameter shares a name with one of them, the parameter wins.
- Reduce with a starting value:
%objects% reduced with %lambda% from %object% lets you set what the total starts at. An empty list just gives back the starting value, and the start can be a different type than the items (like joining a list of items into one piece of text).
- More owner types:
owner: used to really only work for players. Now an entity, chunk, or world can own a listener too. It cleans itself up automatically when the owner goes away, a player logging off, an entity dying or despawning, or a chunk/world unloading. (Teleporting between worlds no longer wrongly kills a player's listeners.)
- Use lambdas from Java: developers can turn a Skript lambda straight into a normal Java function with
asPredicate(),
asFunction(),
asBiFunction(),
asConsumer(), and
asSupplier().
1.0.0 24 days, 21 hours and 39 minutes ago
skLambda 1.0.0
Supports: Paper 1.21.1+ · Skript 2.15+
New expressions
List loops can now be written as one-line operations instead of Skript
loop blocks. Each one runs a lambda or predicate over a list.
- Mapped:
%objects% mapped with %lambda% turns every element into something new.
- Filtered:
%objects% filtered where %predicate% passes keeps only the elements that pass.
- Reduced:
%objects% reduced with %lambda% folds the whole list down to a single value.
- Sorted:
%objects% sorted by %lambda% sorts the list using a key pulled from each element.
- Count Where:
count of %objects% where %predicate% passes counts how many elements pass.
- First Where:
first element of %objects% where %predicate% passes returns the first element that passes.
- End Reason:
end reason reports why a listener stopped, so you can branch on it. Comes with its own type.
New functions
- Constant predicates:
always() and
never() are drop-in predicates.
always() always passes and
never() never passes.
New listener options
These go inside a listen section.
-
owner: ties a listener to an owner (for example a player). When the owner disconnects, the listener unregisters itself.
-
on end: a callback that always runs no matter how the listener stops (completion, timeout, cancel, unregister, or owner disconnect). One single cleanup path.
-
cooldown: %timespan% debounces rapid re-triggers. A debounced event does not run
on trigger and does not count toward
triggers:.
-
every %timespan%: a repeating timer callback that runs while the listener is active. It pauses and stops along with the listener.
New effect
- Unregister owned listeners:
unregister all listeners owned by %object% stops only the listeners tied to that owner, for scoped cleanup.
Update checker
- Startup check:
update-notifications now actually works (it used to be a reserved toggle that did nothing). On startup the plugin checks for newer releases and notifies op players when they join.
Improvements
-
/sklambda command: now has tab-completion, and
/sklambda listeners shows owner info for each listener. The plugin link now points to Modrinth instead of GitHub.
- Internal refactor: element registration was split into
LambdaModule and
ListenerModule, trimming the main
SkLambda class by about 90 lines.
- Examples:
example.sk gained 5 new showcases (
10 to
14) covering the features above.
- Build: version bumped to
1.0.0.
Full Changelog: git... 1.0.0
Changelog 0.0.3-alpha 26 days, 11 hours and 12 minutes ago
Supports: Paper 1.21.1+ · Skript 2.15+
New expressions
- Inline Lambda: write a lambda on one line:
lambda (p: player): {_p} is op. The body is either a condition, which acts as a predicate returning
true/
false, or an effect, which runs and returns nothing. Parameters become locals like
{_p}.
- Function Lambda:
function lambda "name" wraps an existing Skript
function in a lambda you can store, pass around, and call like any other lambda.
- Call Lambda new forms: alongside
call/
invoke lambda, you can now write
calling lambda %lambda% [with ...] and
the result of calling lambda %lambda% [with ...].
New condition
- Predicate Passes: treat a lambda as a yes/no test:
%lambdas% pass[es] [for %values%], also readable as
matches or
holds. With a list of lambdas, a quantifier decides how many must pass:
all of, which is the default,
any of, or
none of. Negate with
doesn't pass or a leading
not. Works inside
listen ... where, too.
New effects
- Unregister All Listeners:
unregister all listeners stops every active listener on the server, across all scripts.
- Unregister Last Listener:
unregister the last created listener stops the most recently created one that is still active. Neither fires
on completion or
on timeout.
New command
- /sklambda: shows the version and GitHub link.
/sklambda listeners lists every active listener, including where it was created, the event it watches, and how long it has been alive. Alias:
/skl. Guarded by the
sklambda.admin permission, defaulting to op.
Configuration
- config.yml added. Toggle features with
lambda and
listener. A disabled feature registers no syntax at all. Both default to
true.
- Listener leak detector (
notifier): optional console warnings about listeners that stay registered longer than
warn-after, repeated every
warn-every, with a customizable
message. Supported placeholders:
{location},
{event},
{duration}. Off by default.
-
update-notifications toggle reserved for a future update check.
Improvements
- Type hints: lambda and saved-listener variables now register a Skript type hint, so misuse is caught at parse time when a script opts into Skript's experimental
using type hints.
- Listener effects and conditions, including
register,
unregister,
pause,
resume, and the registered/paused/running checks, now take a
%listener% instead of
%object%, giving clearer errors.
-
remaining triggers and
remaining countdown share a common base and now report
0 correctly once a listener has finished.
- Website link now points to GitHub.
skLambda 27 days, 10 hours and 7 minutes ago
A Skript addon that lets you treat behavior as a value, and cut a lot of boilerplate while you're at it. It adds:
- Lambdas: Small functions you save in a variable, pass around, and run later. They support closures, default parameters, and piping.
- Predicates: Reusable yes/no tests you can combine with all, any, or none, or count how many pass.
- List operations: Map, reduce, scan, zip, sort, highest/lowest, and paging, without writing the loops yourself.
- Self-cleaning listeners: Temporary event listeners scoped to one player or command, with a timer, a hit count, and lifecycle callbacks. They stop themselves.
- Async: Run a lambda off the main thread with futures,
wait for an event or result without freezing the server, and
watch a value or condition.
Links
Example: same task, two ways
The task: tell the player to mine 10 stone in 30 seconds. Give a diamond if they finish, say "too slow" if they don't.
Without skLambda
on break of stone:
if {challenge::%player%} is not set:
stop
add 1 to {challenge::progress::%player%}
if {challenge::progress::%player%} >= 10:
send "you did it!" to player
give 1 diamond to player
delete {challenge::%player%}
delete {challenge::progress::%player%}
command /challenge:
trigger:
set {challenge::%player%} to true
set {challenge::progress::%player%} to 0
send "mine 10 stone in 30s" to player
wait 30 seconds
if {challenge::%player%} is set:
send "too slow" to player
delete {challenge::%player%}
delete {challenge::progress::%player%}
if {challenge::%player%} is not set:
stop
add 1 to {challenge::progress::%player%}
if {challenge::progress::%player%} >= 10:
send "you did it!" to player
give 1 diamond to player
delete {challenge::%player%}
delete {challenge::progress::%player%}
command /challenge:
trigger:
set {challenge::%player%} to true
set {challenge::progress::%player%} to 0
send "mine 10 stone in 30s" to player
wait 30 seconds
if {challenge::%player%} is set:
send "too slow" to player
delete {challenge::%player%}
delete {challenge::progress::%player%}
Lots to do by hand: a global on break of stone that runs for every player, a flag variable, a counter variable, a separate wait for the timeout, and delete lines everywhere to clean up.
With skLambda
command /challenge:
trigger:
send "mine 10 stone in 30s" to player
listen for block break where event-block is stone:
countdown: 30 seconds
triggers: 10
every 1 second:
send action bar "%remaining triggers% left — %remaining countdown%" to event-player
on completion:
send "you did it!" to event-player
give 1 diamond to event-player
on timeout:
send "too slow!" to event-player
trigger:
send "mine 10 stone in 30s" to player
listen for block break where event-block is stone:
countdown: 30 seconds
triggers: 10
every 1 second:
send action bar "%remaining triggers% left — %remaining countdown%" to event-player
on completion:
send "you did it!" to event-player
give 1 diamond to event-player
on timeout:
send "too slow!" to event-player
That's it. The listener belongs to this one command run. The counter, the timer, and the live action-bar readout are built in, and when it finishes or times out, it cleans up by itself.
More than listeners
Save a test and run it over a list. Predicates pair with Skript's own filter, and list operations skip the loop:
# keep only the players who are AFK
set {_afk} to lambda (p: player): {_p}'s idle time > 5 minutes
set {_idle::*} to all players where [{_afk} passes for input]
# score every player with a lambda, grab the winner
set {_score} to lambda (p: player) -> number:
return {_p}'s level
set {_mvp} to highest of all players by {_score}
set {_afk} to lambda (p: player): {_p}'s idle time > 5 minutes
set {_idle::*} to all players where [{_afk} passes for input]
# score every player with a lambda, grab the winner
set {_score} to lambda (p: player) -> number:
return {_p}'s level
set {_mvp} to highest of all players by {_score}
New in 1.3.0, you can pause a trigger and wait without freezing the server:
command /confirm:
trigger:
send "type 'yes' in chat within 15s to confirm." to player
wait for next chat where player is sender within 15 seconds:
if message is "yes":
send "confirmed!" to player
on timeout:
send "cancelled — no reply." to player
trigger:
send "type 'yes' in chat within 15s to confirm." to player
wait for next chat where player is sender within 15 seconds:
if message is "yes":
send "confirmed!" to player
on timeout:
send "cancelled — no reply." to player
The trigger picks up right where it left off when the player chats, and the server keeps ticking the whole time. You can also wait for a background job ( future of calling lambda ...) or watch a value or condition and react only when it changes.
Full guides and dozens of runnable examples are on the wiki.
Requirements
License
MIT
Stats
skLambda uses bStats for anonymous usage stats. You can opt out in plugins/bStats/config.yml.
Notes
If you experience any problems, let me know on Discord eult, discord server.