Kap: Difference between revisions
Jump to navigation
Jump to search
(Added some more information about KAP) |
No edit summary |
||
| Line 1: | Line 1: | ||
{{Infobox array language | {{Infobox array language | ||
| array model = [[ | | array model = [[nested array model|nested]] | ||
| index origin = 0 | | index origin = 0 | ||
| function styles = block (like [[dfn]]s) | | function styles = block (like [[dfn]]s) | ||
| Line 9: | Line 9: | ||
| latest release version = 2020 (unversioned) | | latest release version = 2020 (unversioned) | ||
| implementation languages = [[wikipedia:Kotlin_(Programming_Language)|Kotlin]] | | implementation languages = [[wikipedia:Kotlin_(Programming_Language)|Kotlin]] | ||
| source = [https://github.com/lokedhs/array] | | source = [https://github.com/lokedhs/array GitHub] | ||
| platforms = JVM, Native, In-browser, [[wikipedia:Node.js|Node.js]] | | platforms = JVM, Native, In-browser, [[wikipedia:Node.js|Node.js]] | ||
| license = MIT | | license = MIT | ||
| file ext = .kap | | file ext = .kap | ||
| influenced by = | | influenced by = [[Dyalog APL]] | ||
| run online = [https://kapdemo.dhsdevelopments.com/] | | run online = [https://kapdemo.dhsdevelopments.com/ JS Client] | ||
}} | }} | ||
'''KAP''' is an array-based language that aims to implement most of standard APL, along with additional features. Much of standard APL works in KAP, although if an APL feature does not fit with KAP's design, those features are changed or removed. | '''KAP''' is an array-based language that aims to implement most of standard APL, along with additional features. Much of standard APL works in KAP, although if an APL feature does not fit with KAP's design, those features are changed or removed. | ||
== Lazy evaluation == | |||
The main difference compared to APL is that KAP is lazy-evaluated. This means that the language gives the developers very loose guarantees when (or if, and how many times) a function will actually be invoked. For example, the following code will only make a single call to the function: | The main difference compared to APL is that KAP is lazy-evaluated. This means that the language gives the developers very loose guarantees when (or if, and how many times) a function will actually be invoked. For example, the following code will only make a single call to the function: | ||
| Line 29: | Line 29: | ||
This is because the call to <code>f¨ ⍳10</code> will not immediately evaluate the result but only return a delayed evaluation. Since all but the first result is then discarded, those results will never be computed. | This is because the call to <code>f¨ ⍳10</code> will not immediately evaluate the result but only return a delayed evaluation. Since all but the first result is then discarded, those results will never be computed. | ||
== Differences from APL == | |||
The following is a list of significant differences compared to APL: | The following is a list of significant differences compared to APL: | ||
| Line 37: | Line 37: | ||
* Ability to define custom syntax | * Ability to define custom syntax | ||
* Native hash table support | * Native hash table support | ||
{{APL dialects}}[[Category:APL dialects]][[Category:Nested array languages]][[Category:Leading axis languages]] | |||
Revision as of 13:13, 26 November 2020
KAP is an array-based language that aims to implement most of standard APL, along with additional features. Much of standard APL works in KAP, although if an APL feature does not fit with KAP's design, those features are changed or removed.
Lazy evaluation
The main difference compared to APL is that KAP is lazy-evaluated. This means that the language gives the developers very loose guarantees when (or if, and how many times) a function will actually be invoked. For example, the following code will only make a single call to the function:
↑ f¨ ⍳10
This is because the call to f¨ ⍳10 will not immediately evaluate the result but only return a delayed evaluation. Since all but the first result is then discarded, those results will never be computed.
Differences from APL
The following is a list of significant differences compared to APL:
- Lazy evaluation
- All values are immutable, it is not possible to modify the content of an array
- Ability to define custom syntax
- Native hash table support
| APL dialects [edit] | |
|---|---|
| Maintained | APL+Win ∙ APL2 ∙ APL64 ∙ APL\iv ∙ Aplette ∙ April ∙ Co-dfns ∙ Dyalog APL ∙ Dyalog APL Vision ∙ dzaima/APL ∙ GNU APL ∙ Kap ∙ NARS2000 ∙ Pometo ∙ TinyAPL |
| Historical | A Programming Language ∙ A+ (A) ∙ APL# ∙ APL2C ∙ APL\360 ∙ APL/700 ∙ APL\1130 ∙ APL\3000 ∙ APL.68000 ∙ APL*PLUS ∙ APL.jl ∙ APL.SV ∙ APLX ∙ Extended Dyalog APL ∙ Iverson notation ∙ IVSYS/7090 ∙ NARS ∙ ngn/apl ∙ openAPL ∙ Operators and Functions ∙ PAT ∙ Rowan ∙ SAX ∙ SHARP APL ∙ Rationalized APL ∙ VisualAPL (APLNext) ∙ VS APL ∙ York APL |
| Derivatives | AHPL ∙ BQN ∙ CoSy ∙ ELI ∙ Glee ∙ I ∙ Ivy ∙ J ∙ Jelly ∙ K (Goal, Klong, Q) ∙ KamilaLisp ∙ Lang5 ∙ Lil ∙ Nial ∙ RAD ∙ Uiua |
| Overviews | Comparison of APL dialects ∙ Timeline of array languages ∙ Timeline of influential array languages ∙ Family tree of array languages |