https://mw.lojban.org/api.php?action=feedcontributions&feedformat=atom&user=RamcinfoLojban - User contributions [en]2026-11-05T05:57:53ZUser contributionsMediaWiki 1.46.2https://mw.lojban.org/index.php?title=User:Ramcinfo/scope_study&diff=121243User:Ramcinfo/scope study2016-09-23T12:29:39Z<p>Ramcinfo: </p>
<hr />
<div>Scope operators are things that modify predications as a whole (bridi operators) or predicates (selbri operators). They are: tenses, some (or all, depending on whom you ask) modals, {na} negation, {da}, outer quantifiers, connectives, and constructs modified by {ji'a} and {po'o}. They are called scope operators because when multiple are present in the same bridi, they modify the bridi in the order based on their order in the bridi text.<br />
<br />
== Tenses and modals ==<br />
When one operator modifies the result of another, it is said for latter to be in the scope of former.<ref>http://lojban.github.io/cll/10/13/, example 13.7</ref><br />
<br />
[va'o ti] [ba] culno fa lo kabri [se va'u mi]<br />
<br />
Linking operator to selbri with {be} allows to incorporate it into the selbri. It acts on selbri only, producing new, modified selbri, so it scopes after all other operators (and even after regular sumti, in a way).<br />
<br />
[va'o ti] [ba] cunlo ⟨be di'a⟩ fa lo kabri [se va'u mi]<br />
<br />
Another way to incorporate an operator into selbri is {jai}-conversion. Such a link will have scope below operators linked with {be}, if any:<br />
<br />
ma [va'o ti] [ba] ⟨jai gau⟩ cunlo ⟨be di'a⟩ fai lo kabri [se va'u mi]<br />
<br />
The order of bridi operators relative to other parts of bridi (being selbri and sumti) is irrelevant. Let us move them all in front of bridi. (We're adding {ku} to {ba} to turn it into sumti tcita from selbri tcita, so it could be an independent term.)<br />
<br />
[va'o ti] [ba ku] [se va'u mi] (⟨di'a ku⟩ ⟨gau ma⟩ culno) fa lo kabri<br />
<br />
The operators modify the meaning of the sumti in this way:<br />
<br />
(va'o ti (ba ku (se va'u mi ((di'a ku (gau ma (culno))) fa lo kabri))))<br />
<br />
or using composition and reverse-apply operators:<br />
<br />
(va'o ti ∘ ba ku ∘ se va'u mi)(d'a ku ∘ gau ma ∘ culno)(fa lo kabri)<br />
<br />
The following happens in present context:<br />
The following happens in the future:<br />
The following happens for me:<br />
The thing is a cup<br />
This is done again:<br />
This is done by whom, I want to know.<br />
The thing is full.<br />
<br />
<br />
It should be noted what a tense stating both direction and interval is one operator; and in fact such tenses give their component in order reverse to the order of operators, e.g. {puzi} is equivalent to {ziku puku}.<br />
<br />
== Quantifiers ==<br />
<br />
{na}, absent in the example above, behaves the same way, as do outer quantifiers — except the latter create {da}* variables behind the scene:<br />
<br />
mi na pendo ci gerku => [na ku] [ci da poi gerku] zo'u mi pendo da<br />
<br />
"It is not true what each of four dogs is my pet"<br />
<br />
mi pendo ci gerku naku => [ci da poi gerku] [na ku] zo'u mi pendo da<br />
<br />
"For each of four dogs, it is not true what it is my pet"<br />
(e.g. no one of four dogs is my pet)<br />
<br />
== Connectives ==<br />
<br />
Logical connectives could be reduced to outer quantifiers, but it easier to expand them to bridi connectives. For latter, scope of operator inside first connected bridi ends at the end of the bridi, before the connective:<br />
<br />
(mi [na] sipta'i) .ije (mi gleki)<br />
<br />
"I am not sleepy. And I am happy"<br />
<br />
Scope of any operator could be extended to the connected predicates through common prenex:<br />
<br />
[naku] zo'u (mi sipta'i) .ije (mi gleki)<br />
<br />
"It is not true what (I am sleepy and I am happy)"<br />
<br />
Other connectives are expanded to bridi connectives:<br />
<br />
mi [na] (sipta'i) je (gleki) => [na] zo'u (mi sipta'i) .ije (mi gleki)<br />
mi (sipta'i) je (gleki) naku => (mi sipta'i [naku]) .ije (mi gleki [naku])<br />
<br />
mi [na] (sipta'i) gi'e (gleki) => (mi [na] sipta'i) .ije (mi gleki)<br />
mi [naku] (sipta'i) gi'e (gleki) => [naku] zo'u (mi sipta'i) .ije (mi gleki)<br />
mi (sipta'i) gi'e (gleki [naku]) => (mi sipta'i) .ije (mi gleki [naku])<br />
mi (sipta'i) gi'e (gleki vau) [naku] => (mi sipta'i [naku]) .ije (mi gleki [naku])<br />
<br />
mi .e do [na] sipta'i => (mi [na] sipta'i) .ije (do [na] sipta'i)<br />
naku mi .e do sipta'i => [naku] zo'u (mi sipta'i) .ije (mi gleki)<br />
<br />
== Todo ==<br />
<br />
* Rewrite more clearly.<br />
* Review with other Lojbanists.<br />
<br />
== Credits ==<br />
Study done with the help of omni___, xorxes, Ilmen, gleki and latro`a; and maybe someone I forgot to mention — sorry, then.<br />
<br />
== Followup ==<br />
This study is close to la tersmu predicate logic analysis, but diverges from it in some points.<br />
<br />
[va'o ti] [ba] culno fa lo kabri [se va'u mi]<br />
<br />
kabri(c0)<br />
(va'o)(ti). (ba)(). (se va'u)(mi). culno(c0)<br />
<br />
cy no kabri<br />
.i [va'o ti] [ba ku] [se va'u mi] zo'u cy no culno<br />
<br />
Fisrt, la tersmu doesn't distinguish modification of selbri with {be} from modification of bridi with sumti-tags; both threated as modification of bridi, and scoped in order of appearance:<br />
<br />
[va'o ti] [ba] cunlo ⟨be di'a⟩ fa lo kabri [se va'u mi]<br />
<br />
kabri(c0)<br />
(va'o)(ti). (ba)(). (di'a)() (se va'u)(mi). culno(c0)<br />
<br />
cy no kabri<br />
.i [va'o ti] [ba ku] ⟨di'a ku⟩ [se va'u mi] zo'u cy no culno<br />
<br />
{jai}-conversion, on the other hand, scopes last, after all other modification, but still modifies the whole bridi:<br />
<br />
⟨ma⟩ [va'o ti] [ba] ⟨jai gau⟩ cunlo ⟨be di'a⟩ fai lo kabri [se va'u mi]<br />
<br />
kabri(c0)<br />
? x1. (va'o)(ti). (ba)(). (di'a)(). (se va'u)(mi). (gau)(x1). cunlo(c0)<br />
<br />
cy no kabri<br />
.i ma goi ko'a [va'o ti] [ba ku] ⟨di'a ku⟩ [se va'u mi] ⟨gau ko'a⟩ zo'u cy no culno<br />
<br />
Compare with my analysis:<br />
<br />
[va'o ti] [ba ku] [se va'u mi] (⟨di'a ku⟩ ⟨gau ma⟩ culno) fa lo kabri<br />
<br />
Second, there is slight difference in analysis of {na}: if it scopes last, la tersmu doesn't place it in prenex:<br />
<br />
na ku va'o ti broda<br />
<br />
!(va'o)(ti). broda( )<br />
<br />
na ku va'o ti zo'u broda<br />
<br />
but:<br />
<br />
va'o ti na ku broda<br />
<br />
(va'o)(ti). !broda( )<br />
<br />
va'o ti zo'u na ku broda<br />
<br />
Finally, la tersmu doesn't handle scopes of connectives:<br />
<br />
mi [na] (sipta'i) je (gleki)<br />
<br />
!<sipta'i(_)){je}<gleki(_)>(mi)<br />
<br />
[na ku] mi (ke sipta'i ke'e) je (ke gleki ke'e)<br />
<br />
gives same result as:<br />
<br />
mi (sipta'i) je (gleki) naku<br />
<br />
!<sipta'i(_)){je}<gleki(_)>(mi)<br />
<br />
[na ku] mi (ke sipta'i ke'e) je (ke gleki ke'e)</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/sumti_staile&diff=121175User:Ramcinfo/sumti staile2016-08-27T20:16:03Z<p>Ramcinfo: </p>
<hr />
<div>(Please note that this draft requires at least passing knowledge of both Kēlen, a beautiful verbless conlang, and Lojban. Author hopes to write more in-depth introduction in future.)<br />
<br />
Imitating Kēlen in Lojban seems at first to be impossible, or at least, very awkward - after all, Lojban is built upon predicates, and predicates are often thought of as verbs (and adjectives). Most sumti, being descriptions, have a predicate in heart. On the other hand, if we consider simple descriptions of {lo broda} kind sort of atomic noun-like constructs, and look at Kēlen relationals as predicates, the task seems to be trivial. However, we can do better.<br />
<br />
First, note that grammar of Lojban allows fragments - predicate-less constructions which can pe used at the same level as usual statements. Original semantics of fragments is to be short answers to various king of questions (“Who Did You Pass On The Road? Nobody”), but in general the grammar doesn't define semantics, and fragments are used by Lojbanists in various roles, e.g. in poetry. One kind of fragment is a bare terms sequence. We'll take the simplest term fragment, then, and interpret it as analogue of LA relational in it simplest pattern ([http://www.terjemar.net/relats2.php#la]):<br />
<br />
lo kabri<br />
la jacēla;<br />
"A bowl exists."<br />
<br />
Let us skip locatives for a moment and look at the other two patterns. Doesn't them remind you of anything? But of course!<br />
<br />
lo kabri po'u lo xunre<br />
la jacēla ñe janēla;<br />
"The bowl is the red thing."<br />
<br />
lo ka xunre po'e lo kabri<br />
"The redness belongs to the bowl."<br />
la jacēla pa annēla;<br />
"The bowl has redness."<br />
<br />
The equivalence pattern translation is very straighforward. The whole-part relationship is more complex; first note that {{vlapoi|ka}} abstraction take place of Kēlen's stative inflection. Also, relationship is reversed in Lojban, the main sumti being possessed and relative one, possessor. However, if we replace possession with association, the order could be made the same as in Kēlen:<br />
<br />
lo kabri pe lo ka xunre<br />
"The bowl is associated with the redness."<br />
<br />
Now, let's return to the locative. By another quirk of the grammar, relative phrases could be not just sumti, but tagged terms. And lo, sumti tensed by another sumti!<br />
<br />
lo kabri pe ga'u re'o lo jubme<br />
la jacēla sū jatēwa;<br />
"The bowl is on the table."<br />
<br />
Now to the other Kēlen relationals.<br />
<br />
ñi jacēla jahūwa;<br />
"The bowl is broken" or "The bowl broke." <br />
<br />
Simplest way of expressing change ([http://www.terjemar.net/relats2.php#ni]) I can think of is temporal tense. Now, pedantically, in Lojban tenses used as sumti tcita generally take {{vlapoi|nu}}-abstractons:<br />
<br />
lo kabri pe co'a lo za'i spofu<br />
"The bowl is beginning to be in broken state"<br />
<br />
However, maybe it could be idiomatically simplified (though motivation here is mostly to imitate Kēlen more closely):<br />
<br />
lo kabri po'u co'a lo spofu<br />
"The bowl is beginning to be broken thing"<br />
<br />
<br />
However, it is difficult to express agency in this way as easily as it is done in Kēlen.<br />
<br />
ñalla jacēla jahūwa;<br />
"I broke the bowl."<br />
<br />
Agency is naturally expressed in lojban with {{vlapoi|gau}}, which is modal formed from predicate {{vlapoi|gasnu}} - so note that we now introduce another way to use predicates in this staile, besides simple descriptions. One approach is add another relative phrase:<br />
<br />
lo kabri pe co'a lo za'i spofu pe gau mi<br />
"The bowl is associated with beginning of broken state, and this state is associated with me as agent."<br />
<br />
- but note that here second association is with the abstraction (state itself), and not with its beginning. Maybe it is more fitting to move the event contour inside description:<br />
<br />
lo kabri pe lo mu'e co'a spofu pe gau mi<br />
"The bowl is associated with beginning of broken condition, and this beginning is associated with me as agent."<br />
<br />
Or in identity pattern:<br />
<br />
lo kabri po'u lo co'a spofu pe gau mi<br />
"The bowl is starting-to-be-broken thing, which is associated with me as agent."<br />
<br />
<br />
However, in doing so, we moved dangerously close to have full-flanged predicate in relative phrase :)<br />
<br />
lo kabri pe lo mu'e gau mi co'a spofu<br />
"The bowl is associated with me causing beginning of broken condition."<br />
<br />
Kēlen ⟨ā⟩ and ⟨tō⟩ correspond to {{vlapoi|zu'e }} and {{vlapoi|bai}}:<br />
<br />
lo bisli po'u lo runme pe zu'e la solri<br />
ñamma anēlki ankehāri ā malō;<br />
"The Sun melted the ice."<br />
<br />
lo bisli po'u lo runme pe bai lo glanejni<br />
ñi anēlki ankehāri tō ancālli;<br />
"The heat melted the ice."<br />
<br />
Unfortunately, I cannot yet see the unified way to translate transaction relational ([http://www.terjemar.net/relats2.php#se]). For purely physical transaction, spatial tenses could be used, but in other types of transaction it would be too metaphorical for Lojban. The only approach I see now is to use various modals, which have two downsides: 1) for various kinds of transactions, various modals are used; and 2) in most typical cases, modal is reduplicated. E.g.:<br />
<br />
lo jdini pe va'u mi zi'e pe seva'u ko'a<br />
telme antēnni pē<br />
"I gave him some money."<br />
<br />
Here, {{vlapoi|va'u}} ({{vlapoi|xamgu}} modal) is used in place of {{vlapoi|dunda}}. Both sides of transaction represent the places of the same predicate, so its modal must be repeated two times in separate relative phrases.<br />
<br />
One could point that using {{vlapoi|xamgu}} for both sides of this kind of transaction is not very appropriate, as though x2 of xamgu is indeed one receiving the benefit, x1 is not source of the benefit, but the benefit itself. So, {lo jdini pe gau mi zi'e pe seva'u ko'a} might be more fitting. This argument shows yet another problem with this approach: connecting source and destination of transaction with {{vlapoi|zi'e}} creates no direct semantic link between them - in this case, the more direct translation should be "The money have me as agent and him as beneficiary", but it must be inferred that my agency is indeed the benifit of another person. This could be amended for in the same way as with NI relational:<br />
<br />
lo jdini pe seva'u ko'a pe gau mi<br />
<br />
However, this variant has a problem of {pe gau mi} associating with {ko'a} and not with the whole term. Another way is to use modal connective:<br />
<br />
lo jdini pe ko'a [ju']e va'u bo mi<br />
<br />
or a forethought termset:<br />
<br />
lo jdini pe nu'i gau mi seva'u ko'a<br />
<br />
Of course, this is bordering on awkward way to say {lo jdini pe lo nu gau mi xamgu ko'a}.<br />
<br />
Finally, PA relational([http://www.terjemar.net/relats2.php#pa]) is mostly shorthand for possessive pattern of LA, as noted in Kēlen grammar itself. It has additional meaning allowing abstractions to be possessors; but in Lojban it may be just expressed with (admittedly vague) {{vlapoi|pe}}:<br />
<br />
lo (ka/za'i)badri pe ko'a<br />
- or -<br />
ko'a po lo (ka/za'i) badri<br />
pa anlōrāl sāen;<br />
"She is grieving." (Lit: "Grief has her.")</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/sumti_staile&diff=121146User:Ramcinfo/sumti staile2016-08-14T20:56:13Z<p>Ramcinfo: termset variant of transaction relational</p>
<hr />
<div>(Please note that this draft requires at least passing knowledge of both Kēlen, a beautiful verbless conlang, and Lojban. Author hopes to write more in-depth introduction in future.)<br />
<br />
Imitating Kēlen in Lojban seems at first to be impossible, or at least, very awkward - after all, Lojban is built upon predicates, and predicates are often thought of as verbs (and adjectives). Most sumti, being descriptions, have a predicate in heart. On the other hand, if we consider simple descriptions of {lo broda} kind sort of atomic noun-like constructs, and look at Kēlen relationals as predicates, the task seems to be trivial. However, we can do better.<br />
<br />
First, note that grammar of Lojban allows fragments - predicate-less constructions which can pe used at the same level as usual statements. Original semantics of fragments is to be short answers to various king of questions (“Who Did You Pass On The Road? Nobody”), but in general the grammar doesn't define semantics, and fragments are used by Lojbanists in various roles, e.g. in poetry. One kind of fragment is a bare terms sequence. We'll take the simplest term fragment, then, and interpret it as analogue of LA relational in it simplest pattern ([http://www.terjemar.net/relats2.php#la]):<br />
<br />
lo kabri<br />
la jacēla;<br />
"A bowl exists."<br />
<br />
Let us skip locatives for a moment and look at the other two patterns. Doesn't them remind you of anything? But of course!<br />
<br />
lo kabri po'u lo xunre<br />
la jacēla ñe janēla;<br />
"The bowl is the red thing."<br />
<br />
lo ka xunre po'e lo kabri<br />
"The redness belongs to the bowl."<br />
la jacēla pa annēla;<br />
"The bowl has redness."<br />
<br />
The equivalence pattern translation is very straighforward. The whole-part relationship is more complex; first note that {{vlapoi|ka}} abstraction take place of Kēlen's stative inflection. Also, relationship is reversed in Lojban, the main sumti being possessed and relative one, possessor. However, if we replace possession with association, the order could be made the same as in Kēlen:<br />
<br />
lo kabri pe lo ka xunre<br />
"The bowl is associated with the redness."<br />
<br />
Now, let's return to the locative. By another quirk of the grammar, relative phrases could be not just sumti, but tagged terms. And lo, sumti tensed by another sumti!<br />
<br />
lo kabri pe ga'u re'o lo jubme<br />
la jacēla sū jatēwa;<br />
"The bowl is on the table."<br />
<br />
Now to the other Kēlen relationals.<br />
<br />
ñi jacēla jahūwa;<br />
"The bowl is broken" or "The bowl broke." <br />
<br />
Simplest way of expressing change ([http://www.terjemar.net/relats2.php#ni]) I can think of is temporal tense. Now, pedantically, in Lojban tenses used as sumti tcita generally take {{vlapoi|nu}}-abstractons:<br />
<br />
lo kabri pe co'a lo za'i spofu<br />
"The bowl is beginning to be in broken state"<br />
<br />
However, maybe it could be idiomatically simplified (though motivation here is mostly to imitate Kēlen more closely):<br />
<br />
lo kabri po'u co'a lo spofu<br />
"The bowl is beginning to be broken thing"<br />
<br />
<br />
However, it is difficult to express agency in this way as easily as it is done in Kēlen.<br />
<br />
ñalla jacēla jahūwa;<br />
"I broke the bowl."<br />
<br />
Agency is naturally expressed in lojban with {{vlapoi|gau}}, which is modal formed from predicate {{vlapoi|gasnu}} - so note that we now introduce another way to use predicates in this staile, besides simple descriptions. One approach is add another relative phrase:<br />
<br />
lo kabri pe co'a lo za'i spofu pe gau mi<br />
"The bowl is associated with beginning of broken state, and this state is associated with me as agent."<br />
<br />
- but note that here second association is with the abstraction (state itself), and not with its beginning. Maybe it is more fitting to move the event contour inside description:<br />
<br />
lo kabri pe lo mu'e co'a spofu pe gau mi<br />
"The bowl is associated with beginning of broken condition, and this beginning is associated with me as agent."<br />
<br />
Or in identity pattern:<br />
<br />
lo kabri po'u lo co'a spofu pe gau mi<br />
"The bowl is starting-to-be-broken thing, which is associated with me as agent."<br />
<br />
<br />
However, in doing so, we moved dangerously close to have full-flanged predicate in relative phrase :)<br />
<br />
lo kabri pe lo mu'e gau mi co'a spofu<br />
"The bowl is associated with me causing beginning of broken condition."<br />
<br />
Kēlen ⟨ā⟩ and ⟨tō⟩ correspond to {{vlapoi|zu'e }} and {{vlapoi|bai}}:<br />
<br />
lo bisli po'u lo runme pe zu'e la solri<br />
ñamma anēlki ankehāri ā malō;<br />
"The Sun melted the ice."<br />
<br />
lo bisli po'u lo runme pe bai lo glanejni<br />
ñi anēlki ankehāri tō ancālli;<br />
"The heat melted the ice."<br />
<br />
Unfortunately, I cannot yet see the unified way to translate transaction relational ([http://www.terjemar.net/relats2.php#se]). For purely physical transaction, spatial tenses could be used, but in other types of transaction it would be too metaphorical for Lojban. The only approach I see now is to use various modals, which have two downsides: 1) for various kinds of transactions, various modals are used; and 2) in most typical cases, modal is reduplicated. E.g.:<br />
<br />
lo jdini pe va'u mi zi'e pe seva'u ko'a<br />
telme antēnni pē<br />
"I gave him some money."<br />
<br />
Here, {{vlapoi|va'u}} ({{vlapoi|xamgu}} modal) is used in place of {{vlapoi|dunda}}. Both sides of transaction represent the places of the same predicate, so its modal must be repeated two times in separate relative phrases.<br />
<br />
Another way to state the same is to connect not two relative phrases with {{vlapoi|zi'e}}, but two terms inside one relative phrase with forethought termset:<br />
<br />
lo jdini pe nu'i va'u mi seva'u ko'a<br />
<br />
One could point that using {{vlapoi|xamgu}} for both sides of this kind of transaction is not very appropriate, as though x2 of xamgu is indeed one receiving the benefit, x1 is not source of the benefit, but the benefit itself. So, {lo jdini pe gau mi zi'e pe seva'u ko'a} might be more fitting. This argument shows yet another problem with this approach: connecting source and destination of transaction with {{vlapoi|zi'e}} creates no direct semantic link between them - in this case, the more direct translation should be "The money have me as agent and him as beneficiary", but it must be inferred that my agency is indeed the benifit of another person. This could be amended for in the same way as with NI relational:<br />
<br />
lo jdini pe seva'u ko'a pe gau mi<br />
<br />
However, this variant has a problem of {pe gau mi} associating with {ko'a} and not with the whole term. Another way is to use modal connective:<br />
<br />
lo jdini pe ko'a [ju']e va'u bo mi<br />
<br />
Of course, this is bordering on awkward way to say {lo jdini pe lo nu mi xamgu ko'a}.<br />
<br />
Finally, PA relational([http://www.terjemar.net/relats2.php#pa]) is mostly shorthand for possessive pattern of LA, as noted in Kēlen grammar itself. It has additional meaning allowing abstractions to be possessors; but in Lojban it may be just expressed with (admittedly vague) {{vlapoi|pe}}:<br />
<br />
lo (ka/za'i)badri pe ko'a<br />
- or -<br />
ko'a po lo (ka/za'i) badri<br />
pa anlōrāl sāen;<br />
"She is grieving." (Lit: "Grief has her.")</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=121110User:Ramcinfo/fancu staile2016-07-15T10:35:37Z<p>Ramcinfo: /* Comparison with Ross Ogilvie's system */ Mr. Ogilvie removed the essay from his site (http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/), but it is archived on github</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {ka}:<br />
lo goi la xunre xiky ge'u ka [ce'u] klesi [ce'u] fi lo ka xunre kei kei<br />
// var redFilter = function (sample) { return filter(sample, red); }; <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
Or with {emna}:<br />
<br />
'''lo''' se.emna '''be''' la ''fancu'' '''bei''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' se.emna la ''fancu'' ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' se.emna la ''fancu'' ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' se.emna la ''fancu'' ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== Comparison with Ross Ogilvie's system ==<br />
Ross Ogilvie presents a proposal for reformation of mex<ref>https://github.com/RossOgilvie/essays/blob/master/fancu%20bridi%20mekso.html</ref> with some very similar ideas. Here's comparation of his notation with one used here:<br />
<br />
<br />
{| class="wikitable"<br />
|+ fancu staile/fancu bridi mekso comparison<br />
! operation !! Ramcinfo !! Ross Ogilvie<br />
|-<br />
| return value || no special notation<sup>*</sup>, ce'u, ke'a || ce'au<sup>‡</sup><br />
|-<br />
| variable binding || ce'ai<sup>†</sup> || zo'ai<sup>‡</sup> ({ce'ai} is also considered)<br />
|-<br />
| convert function bridi (definition) to sumti (first-class function value) || lo ka || xau<sup>‡</sup> ({ni}, {du'u} and {su'u} are also considered)<br />
|-<br />
| convert function bridi to sumti (result of function application) || lo kai'u<sup>†</sup> (ce'u) / lo'oi<sup>†</sup> (ke'a) || also {xau}<br />
|-<br />
| convert function selbri to sumti (using functions as arguments) || me'ei<sup>†</sup> || ni'e<br />
|-<br />
| convert function sumti to selbri || me'au<sup>†</sup> || me<br />
|-<br />
| partial application || kai'u<sup>†</sup> || be'ei<sup>‡</sup><br />
|-<br />
| function composition || la finti<sup>‡</sup> || fancyjo'e<sup>‡</sup><br />
|-<br />
| curry || la karis.<sup>‡</sup> || na'u<sup>‡</sup><br />
|-<br />
| uncurry || - || nu'a<sup>‡</sup><br />
|-<br />
| list constructor || la zbasu<sup>‡</sup> || ce'o<br />
|-<br />
| map || - || porkanji<sup>‡</sup><br />
|-<br />
| fold || - || porjmina<sup>‡</sup><br />
|-<br />
| filter || klesi || -<br />
|}<br />
<br />
<sup>*</sup> {la jalge} is used for an bound variable argument intended as a return value, but that's pure convention. In Ramcinfo's approach, any bound variable of selbri could be used as argument or return value as needed.<br />
<br />
<sup>†</sup> Experimental<br />
<br />
<sup>‡</sup> Proposed or re-purposed specially for use in these systems<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/lojbo_staile_liste&diff=120809User:Ramcinfo/lojbo staile liste2016-06-01T07:16:04Z<p>Ramcinfo: /* Inspired by fictional languages */</p>
<hr />
<div>Principal purpose of this list is to explore ways to use Lojban different from Indo-European natlang ways.<br />
==Lojban-specific==<br />
* cmavo-only style<ref>[http://www.lojban.org/tiki/tiki-view_forum_thread.php?forumId=5&comments_parentId=7703&topics_offset=324&topics_sort_mode=lastPost_desc Lojban with only cmavo: an Oulipian strategy]</ref>. Could be done in many ways; by using pro-sumti and pro-bridi; by extracting selbri from BAI (now this is easier with {{jvs|xo'i}}) and tenses; by using detailed attitudinals, etc.<br />
==Inspired by real language features==<br />
* {{vlapoi|sumcau|staile}}, inspired by nounless languages like that of Salishan and Wakashan families<ref>[https://www.dropbox.com/s/kvj63dtew6hs3z3/ENG%20Davidson%2CM.%20-%20Studies%20in%20southern%20Wakashan%20%28Nootkan%29%20grammar.pdf?dl=0 A grammar of Nootkah]</ref><ref>[https://en.wikipedia.org/wiki/Lojban#Syntax_and_semantics Example of Lojban imitating Nuu-chah-nulth] (near the end of the section). Note that it is also agglutinative.</ref>.<br />
==Inspired by other constructed languages==<br />
* Verbless style inspired by Kēlen<ref>[http://www.terjemar.net/grammar.php Kēlen Grammar]</ref>. See [[User:Ramcinfo/sumti_staile|the draft]].<br />
* toki pona style, with e.g. anaphora instead of nested constructs ({mi pinxe lo tcati .i mi masno lonu go'i}). Vocabulary might or might not be restricted.<br />
==Inspired by fictional languages==<br />
* Tlön styles, from Borges’ short story. Most Tlön languages lack nouns, so sumti are either avoided or thought of as combinations of properties and/or relations. {{jvs|za'a}} and {{jvs|si'au}} evidentials are common.<br />
:* snanu .utloine staile: in Southern Tlön style, meaning is constructed from verbs and adverbs. Example:<br />
{{mu|mo'i ga'u ku ti'a lo zu'o ru'i flecu cu co'a mluni}}<br />
:* berti .utloine staile: in Northern Tlön style, objects are referred to by combination of adjectives (qualities). Possible lojbanic ways to do so: {{jvs|ka}} and {{jvs|za'i}} abstractions, modals making main level bridi into such abstractions (especially {{vlapoi|se|kai|ku}} and {{vlapoi|se|ri'i|ku}}, also {{vlapoi|se|ci'o|ku}} and {{vlapoi|se|mu'u|ku}}), {{vlapoi|ca'o|nai}} and {{vlapoi|co'i|nai}} event contours, {{jvs|ru'i}} and {{jvs|ze'e}} interval properties. Example:<br />
{{mu|se kai vacri je gusni ne'i lo kai'u narju je kandi je tsani}}<br />
<br />
<br />
{{notci|Note: I am tempted to replace {lo zu'o} and {lo kai'u} with something other in these examples, to completely avoid references to (non-abstract) objects. One way to do so is to use modal connectives, e.g {mo'i ga'u co'a mluni .i ti'a bo ru'i flecu} and {se kai vacri je gunsi .i ne'i bo se kai narju je kandi je tsani}, but they are more removed from the word order of original.}}<br />
* melaxoxengron staile, inspired by “language of dreams” in Max Frei novels. Similar to (especially Northern) Tlön style; default evidential is {{jvs|si'au}}, {{jvs|se'o}} may also be used.<br />
<br />
==Inspired by programming languages==<br />
* {{vlapoi|minde|sampla|staile}}, corresponding to imperative programming paradigm. Instead of claims, predicates are understood as commands. Some attempts are done here: [[Writing algorithms in Lojban]].<br />
* {{vlapoi|fancu|sampla|staile}}, corresponding to functional -"- -"- . Selbri understood as functions. See [[User:Ramcinfo/fancu_staile|the draft]].<br />
* {{vlapoi|logji|sampla|staile}}, corresponding to logical -"- -"- . Early draft is [[User:Ramcinfo/logji_staile|here]]. See also la jimpe<ref>http://web.mit.edu/~rspeer/Public/jimpe.pdf</ref>.<br />
* {{vlapoi|tinsa|tectaipe|staile}}, corresponding to strict typing.<br />
==Miscellaneous==<br />
* Stack staile, based on proglangs like Forth and PostScript and conlangs like [[Fith]] and Nalnuàntir<ref>http://conlang.wikia.com/wiki/Nalnu%C3%A0ntir</ref><br />
* Improvements of mekso, e.g. fancu bridi mekso proposal<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref><br />
=Credits=<br />
Many ideas were proposed by [[la gleki]].<br />
=References=<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/lojbo_staile_liste&diff=120808User:Ramcinfo/lojbo staile liste2016-06-01T06:41:12Z<p>Ramcinfo: </p>
<hr />
<div>Principal purpose of this list is to explore ways to use Lojban different from Indo-European natlang ways.<br />
==Lojban-specific==<br />
* cmavo-only style<ref>[http://www.lojban.org/tiki/tiki-view_forum_thread.php?forumId=5&comments_parentId=7703&topics_offset=324&topics_sort_mode=lastPost_desc Lojban with only cmavo: an Oulipian strategy]</ref>. Could be done in many ways; by using pro-sumti and pro-bridi; by extracting selbri from BAI (now this is easier with {{jvs|xo'i}}) and tenses; by using detailed attitudinals, etc.<br />
==Inspired by real language features==<br />
* {{vlapoi|sumcau|staile}}, inspired by nounless languages like that of Salishan and Wakashan families<ref>[https://www.dropbox.com/s/kvj63dtew6hs3z3/ENG%20Davidson%2CM.%20-%20Studies%20in%20southern%20Wakashan%20%28Nootkan%29%20grammar.pdf?dl=0 A grammar of Nootkah]</ref><ref>[https://en.wikipedia.org/wiki/Lojban#Syntax_and_semantics Example of Lojban imitating Nuu-chah-nulth] (near the end of the section). Note that it is also agglutinative.</ref>.<br />
==Inspired by other constructed languages==<br />
* Verbless style inspired by Kēlen<ref>[http://www.terjemar.net/grammar.php Kēlen Grammar]</ref>. See [[User:Ramcinfo/sumti_staile|the draft]].<br />
* toki pona style, with e.g. anaphora instead of nested constructs ({mi pinxe lo tcati .i mi masno lonu go'i}). Vocabulary might or might not be restricted.<br />
==Inspired by fictional languages==<br />
* Tlön styles, from Borges’ short story. Most Tlön languages lack nouns, so sumti are either avoided or thought of as combinations of properties and/or relations. {{jvs|za'a}} and {{jvs|si'au}} evidentials are common.<br />
:* snanu .utloine staile: in Southern Tlön style, meaning is constructed from verbs and adverbs. Example:<br />
{{mu|mo'i ga'u ku ti'a lo zu'o ru'i flecu cu co'a mluni}}<br />
:* berti .utloine staile: in Northern Tlön style, objects are referred to by combination of adjectives (qualities). Possible lojbanic ways to do so: {{jvs|ka}} and {{jvs|za'i}} abstractions, modals making main level bridi into such abstractions (especially {{vlapoi|se|kai|ku}} and {{vlapoi|se|ri'i|ku}}, also {{vlapoi|se|ci'o|ku}} and {{vlapoi|se|mu'u|ku}}), {{vlapoi|ca'o|nai}} and {{vlapoi|co'i|nai}} event contours, {{jvs|ru'i}} and {{jvs|ze'e}} interval properties. Example:<br />
{{mu|se kai vacri je gusni ne'i lo kai'u narju je kandi je tsani}}<br />
<br />
<br />
{{notci|Note: I am tempted to replace {lo zu'o} and {lo kai'u} with something other in these examples, to completely avoid references to (non-abstract) objects.}}<br />
* melaxoxengron staile, inspired by “language of dreams” in Max Frei novels. Similar to (especially Northern) Tlön style; default evidential is {{jvs|si'au}}, {{jvs|se'o}} may also be used.<br />
<br />
==Inspired by programming languages==<br />
* {{vlapoi|minde|sampla|staile}}, corresponding to imperative programming paradigm. Instead of claims, predicates are understood as commands. Some attempts are done here: [[Writing algorithms in Lojban]].<br />
* {{vlapoi|fancu|sampla|staile}}, corresponding to functional -"- -"- . Selbri understood as functions. See [[User:Ramcinfo/fancu_staile|the draft]].<br />
* {{vlapoi|logji|sampla|staile}}, corresponding to logical -"- -"- . Early draft is [[User:Ramcinfo/logji_staile|here]]. See also la jimpe<ref>http://web.mit.edu/~rspeer/Public/jimpe.pdf</ref>.<br />
* {{vlapoi|tinsa|tectaipe|staile}}, corresponding to strict typing.<br />
==Miscellaneous==<br />
* Stack staile, based on proglangs like Forth and PostScript and conlangs like [[Fith]] and Nalnuàntir<ref>http://conlang.wikia.com/wiki/Nalnu%C3%A0ntir</ref><br />
* Improvements of mekso, e.g. fancu bridi mekso proposal<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref><br />
=Credits=<br />
Many ideas were proposed by [[la gleki]].<br />
=References=<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/lojbo_staile_liste&diff=119428User:Ramcinfo/lojbo staile liste2016-03-11T05:20:07Z<p>Ramcinfo: Modals inversions corrected</p>
<hr />
<div>Principal purpose of this list is to explore ways to use Lojban different from Indo-European natlang ways.<br />
==Lojban-specific==<br />
* cmavo-only style<ref>[http://www.lojban.org/tiki/tiki-view_forum_thread.php?forumId=5&comments_parentId=7703&topics_offset=324&topics_sort_mode=lastPost_desc Lojban with only cmavo: an Oulipian strategy]</ref><br />
==Inspired by real language features==<br />
* {{vlapoi|sumcau|staile}}, inspired by nounless languages like that of Salishan and Wakashan families<ref>[https://www.dropbox.com/s/kvj63dtew6hs3z3/ENG%20Davidson%2CM.%20-%20Studies%20in%20southern%20Wakashan%20%28Nootkan%29%20grammar.pdf?dl=0 A grammar of Nootkah]</ref><ref>[https://en.wikipedia.org/wiki/Lojban#Syntax_and_semantics Example of Lojban imitating Nuu-chah-nulth] (near the end of the section). Note that it is also agglutinative.</ref>.<br />
==Inspired by other constructed languages==<br />
* Verbless style inspired by Kēlen<ref>[http://www.terjemar.net/grammar.php Kēlen Grammar]</ref>. See [[User:Ramcinfo/sumti_staile|the draft]].<br />
* toki pona style, with e.g. anaphora instead of nested constructs ({mi pinxe lo tcati .i mi masno lonu go'i}). Vocabulary might or might not be restricted.<br />
==Inspired by fictional languages==<br />
* Tlön styles, from Borges’ short story. Most Tlön languages lack nouns, so sumti are either avoided or thought of as combinations of properties and/or relations. {{jvs|za'a}} and {{jvs|si'au}} evidentials are common.<br />
:* snanu .utloine staile: in Southern Tlön style, meaning is constructed from verbs and adverbs. Example:<br />
{{mu|mo'i ga'u ku ti'a lo zu'o ru'i flecu cu co'a mluni}}<br />
:* berti .utloine staile: in Northern Tlön style, objects are referred to by combination of adjectives (qualities). Possible lojbanic ways to do so: {{jvs|ka}} and {{jvs|za'i}} abstractions, modals making main level bridi into such abstractions (especially {{vlapoi|se|kai|ku}} and {{vlapoi|se|ri'i|ku}}, also {{vlapoi|se|ci'o|ku}} and {{vlapoi|se|mu'u|ku}}), {{vlapoi|ca'o|nai}} and {{vlapoi|co'i|nai}} event contours, {{jvs|ru'i}} and {{jvs|ze'e}} interval properties. Example:<br />
{{mu|se kai vacri je gusni ne'i lo kai'u narju je kandi je tsani}}<br />
<br />
<br />
{{notci|Note: I am tempted to replace {lo zu'o} and {lo kai'u} with something other in these examples, to completely avoid references to (non-abstract) objects.}}<br />
* melaxoxengron staile, inspired by “language of dreams” in Max Frei novels. Similar to (especially Northern) Tlön style; default evidential is {{jvs|si'au}}, {{jvs|se'o}} may also be used.<br />
<br />
==Inspired by programming languages==<br />
* {{vlapoi|minde|sampla|staile}}, corresponding to imperative programming paradigm. Instead of claims, predicates are understood as commands. Some attempts are done here: [[Writing algorithms in Lojban]].<br />
* {{vlapoi|fancu|sampla|staile}}, corresponding to functional -"- -"- . Selbri understood as functions. See [[User:Ramcinfo/fancu_staile|the draft]].<br />
* {{vlapoi|logji|sampla|staile}}, corresponding to logical -"- -"- . Early draft is [[User:Ramcinfo/logji_staile|here]]. See also la jimpe<ref>http://web.mit.edu/~rspeer/Public/jimpe.pdf</ref>.<br />
* {{vlapoi|tinsa|tectaipe|staile}}, corresponding to strict typing.<br />
==Miscellaneous==<br />
* Stack staile, based on proglangs like Forth and PostScript and conlangs like [[Fith]] and Nalnuàntir<ref>http://conlang.wikia.com/wiki/Nalnu%C3%A0ntir</ref><br />
* Improvements of mekso, e.g. fancu bridi mekso proposal<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref><br />
=Credits=<br />
Many ideas were proposed by [[la gleki]].<br />
=References=<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=Lojban_etymology&diff=119412Lojban etymology2016-03-10T05:02:53Z<p>Ramcinfo: </p>
<hr />
<div>[http://www.lojban.org/publications/etymology/ This directory] contains various Lojban etymology files, some of which are in a format suitable for analysis by the GLOTTO software written by [mailto:jguy@trl.oz.au Jacques Guy]. Includes:<br />
*http://www.lojban.org/publications/etymology/lojban.voc A list of Lojban gismu in no particular order; the other *.voc files contain the same words in each of the six Lojban source languages. Note that the source-language words are in Lojbanized spelling rather than conventional spelling, which makes them hard to recognize. Furthermore, conventional endings have been chopped off, and affricates ("tc", "dj", "ts", "dz") have generally been reduced to simple spirants ("c", "j", "s", "z" respectively), to prevent bogus mismatches. Thus, for example, the Spanish word "hijo" appears as "ix".<br />
*http://www.lojban.org/publications/etymology/lojban.icg The same data, but merged into a single file. The order of words in this file is the same as that in the *.voc files, but the words have been brought together. For each word, the languages are listed in the order Lojban-Chinese-English-Hindi-Spanish-Russian-Arabic. Each word is preceded by the letter "L" if it is Lojban or contributed (score > 0) to the Lojban gismu, or else by the first letter of its language name ("C", "E", "H", "S", "R", or "A") if it made no contribution (score = 0).<br />
*http://www.lojban.org/publications/etymology/etysample.txt Contains sample etymologies for a few gismu, and may be used to get the flavor of Lojban etymologizing.<br />
*http://www.lojban.org/publications/etymology/langstat.94 and http://www.lojban.org/publications/etymology/langstat.95 Reports on the numbers of speakers of various world languages, as of 1994 and 1995. Earlier versions of this data were used to make weighting decisions in gismu construction.<br />
*http://www.lojban.org/publications/etymology/eaton.zip Old Eaton data from an earlier stage of the Loglan Project. Primarily of historical interest, it was an attempt at covering all of the words in Helen Eaton's 1930's list of the most frequently used concepts in 4 European languages. A low priority project is to replace this work with updated Lojban words for each concept.<br />
<br />
All of this data was drawn from the file [http://www.lojban.org/publications/etymology/finprims.html finprims], which contains complete information (with transliterated/transcribed original-language forms) on the Lojban gismu (primitive roots). <br />
<br />
The original-language representations exist only in hardcopy form, but Mublin has been able to reconstruct most of them, with only a few uncertain or missing etymologies. See [https://www.dealloc.org/~mublin/ Mublin's site] (the site is offline, backup can be found here: [https://github.com/cjolowicz/lojban-etymology]).<br />
<br />
Contact [mailto:lojban@lojban.org lojban@lojban.org] for further information.</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/sumti_staile&diff=119411User:Ramcinfo/sumti staile2016-03-10T01:53:20Z<p>Ramcinfo: </p>
<hr />
<div>(Please note that this draft requires at least passing knowledge of both Kēlen, a beautiful verbless conlang, and Lojban. Author hopes to write more in-depth introduction in future.)<br />
<br />
Imitating Kēlen in Lojban seems at first to be impossible, or at least, very awkward - after all, Lojban is built upon predicates, and predicates are often thought of as verbs (and adjectives). Most sumti, being descriptions, have a predicate in heart. On the other hand, if we consider simple descriptions of {lo broda} kind sort of atomic noun-like constructs, and look at Kēlen relationals as predicates, the task seems to be trivial. However, we can do better.<br />
<br />
First, note that grammar of Lojban allows fragments - predicate-less constructions which can pe used at the same level as usual statements. Original semantics of fragments is to be short answers to various king of questions (“Who Did You Pass On The Road? Nobody”), but in general the grammar doesn't define semantics, and fragments are used by Lojbanists in various roles, e.g. in poetry. One kind of fragment is a bare terms sequence. We'll take the simplest term fragment, then, and interpret it as analogue of LA relational in it simplest pattern ([http://www.terjemar.net/relats2.php#la]):<br />
<br />
lo kabri<br />
la jacēla;<br />
"A bowl exists."<br />
<br />
Let us skip locatives for a moment and look at the other two patterns. Doesn't them remind you of anything? But of course!<br />
<br />
lo kabri po'u lo xunre<br />
la jacēla ñe janēla;<br />
"The bowl is the red thing."<br />
<br />
lo ka xunre po'e lo kabri<br />
"The redness belongs to the bowl."<br />
la jacēla pa annēla;<br />
"The bowl has redness."<br />
<br />
The equivalence pattern translation is very straighforward. The whole-part relationship is more complex; first note that {{vlapoi|ka}} abstraction take place of Kēlen's stative inflection. Also, relationship is reversed in Lojban, the main sumti being possessed and relative one, possessor. However, if we replace possession with association, the order could be made the same as in Kēlen:<br />
<br />
lo kabri pe lo ka xunre<br />
"The bowl is associated with the redness."<br />
<br />
Now, let's return to the locative. By another quirk of the grammar, relative phrases could be not just sumti, but tagged terms. And lo, sumti tensed by another sumti!<br />
<br />
lo kabri pe ga'u re'o lo jubme<br />
la jacēla sū jatēwa;<br />
"The bowl is on the table."<br />
<br />
Now to the other Kēlen relationals.<br />
<br />
ñi jacēla jahūwa;<br />
"The bowl is broken" or "The bowl broke." <br />
<br />
Simplest way of expressing change ([http://www.terjemar.net/relats2.php#ni]) I can think of is temporal tense. Now, pedantically, in Lojban tenses used as sumti tcita generally take {{vlapoi|nu}}-abstractons:<br />
<br />
lo kabri pe co'a lo za'i spofu<br />
"The bowl is beginning to be in broken state"<br />
<br />
However, maybe it could be idiomatically simplified (though motivation here is mostly to imitate Kēlen more closely):<br />
<br />
lo kabri po'u co'a lo spofu<br />
"The bowl is beginning to be broken thing"<br />
<br />
<br />
However, it is difficult to express agency in this way as easily as it is done in Kēlen.<br />
<br />
ñalla jacēla jahūwa;<br />
"I broke the bowl."<br />
<br />
Agency is naturally expressed in lojban with {{vlapoi|gau}}, which is modal formed from predicate {{vlapoi|gasnu}} - so note that we now introduce another way to use predicates in this staile, besides simple descriptions. One approach is add another relative phrase:<br />
<br />
lo kabri pe co'a lo za'i spofu pe gau mi<br />
"The bowl is associated with beginning of broken state, and this state is associated with me as agent."<br />
<br />
- but note that here second association is with the abstraction (state itself), and not with its beginning. Maybe it is more fitting to move the event contour inside description:<br />
<br />
lo kabri pe lo mu'e co'a spofu pe gau mi<br />
"The bowl is associated with beginning of broken condition, and this beginning is associated with me as agent."<br />
<br />
Or in identity pattern:<br />
<br />
lo kabri po'u lo co'a spofu pe gau mi<br />
"The bowl is starting-to-be-broken thing, which is associated with me as agent."<br />
<br />
<br />
However, in doing so, we moved dangerously close to have full-flanged predicate in relative phrase :)<br />
<br />
lo kabri pe lo mu'e gau mi co'a spofu<br />
"The bowl is associated with me causing beginning of broken condition."<br />
<br />
Kēlen ⟨ā⟩ and ⟨tō⟩ correspond to {{vlapoi|zu'e }} and {{vlapoi|bai}}:<br />
<br />
lo bisli po'u lo runme pe zu'e la solri<br />
ñamma anēlki ankehāri ā malō;<br />
"The Sun melted the ice."<br />
<br />
lo bisli po'u lo runme pe bai lo glanejni<br />
ñi anēlki ankehāri tō ancālli;<br />
"The heat melted the ice."<br />
<br />
Unfortunately, I cannot yet see the unified way to translate transaction relational ([http://www.terjemar.net/relats2.php#se]). For purely physical transaction, spatial tenses could be used, but in other types of transaction it would be too metaphorical for Lojban. The only approach I see now is to use various modals, which have two downsides: 1) for various kinds of transactions, various modals are used; and 2) in most typical cases, modal is reduplicated. E.g.:<br />
<br />
lo jdini pe va'u mi zi'e pe seva'u ko'a<br />
telme antēnni pē<br />
"I gave him some money."<br />
<br />
Here, {{vlapoi|va'u}} ({{vlapoi|xamgu}} modal) is used in place of {{vlapoi|dunda}}. Both sides of transaction represent the places of the same predicate, so its modal must be repeated two times in separate relative phrases.<br />
<br />
One could point that using {{vlapoi|xamgu}} for both sides of this kind of transaction is not very appropriate, as though x2 of xamgu is indeed one receiving the benefit, x1 is not source of the benefit, but the benefit itself. So, {lo jdini pe gau mi zi'e pe seva'u ko'a} might be more fitting. This argument shows yet another problem with this approach: connecting source and destination of transaction with {{vlapoi|zi'e}} creates no direct semantic link between them - in this case, the more direct translation should be "The money have me as agent and him as beneficiary", but it must be inferred that my agency is indeed the benifit of another person. This could be amended for in the same way as with NI relational:<br />
<br />
lo jdini pe seva'u ko'a pe gau mi<br />
<br />
However, this variant has a problem of {pe gau mi} associating with {ko'a} and not with the whole term. Another way is to use modal connective:<br />
<br />
lo jdini pe ko'a [ju']e va'u bo mi<br />
<br />
Of course, this is bordering on awkward way to say {lo jdini pe lo nu mi xamgu ko'a}.<br />
<br />
Finally, PA relational([http://www.terjemar.net/relats2.php#pa]) is mostly shorthand for possessive pattern of LA, as noted in Kēlen grammar itself. It has additional meaning allowing abstractions to be possessors; but in Lojban it may be just expressed with (admittedly vague) {{vlapoi|pe}}:<br />
<br />
lo (ka/za'i)badri pe ko'a<br />
- or -<br />
ko'a po lo (ka/za'i) badri<br />
pa anlōrāl sāen;<br />
"She is grieving." (Lit: "Grief has her.")</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/sumti_staile&diff=119402User:Ramcinfo/sumti staile2016-03-09T15:39:06Z<p>Ramcinfo: </p>
<hr />
<div>(Please note that this draft requires at least passing knowledge of both Kēlen, a beautiful verbless conlang, and Lojban. Author hopes to write more in-depth introduction in future.)<br />
<br />
Imitating Kēlen in Lojban seems at first to be impossible, or at least, very awkward - after all, Lojban is built upon predicates, and predicates are often thought of as verbs (and adjectives). Most sumti, being descriptions, have a predicate in heart. On the other hand, if we consider simple descriptions of {lo broda} kind sort of atomic noun-like constructs, and look at Kēlen relationals as predicates, the task seems to be trivial. However, we can do better.<br />
<br />
First, note that grammar of Lojban allows fragments - predicate-less constructions which can pe used at the same level as usual statements. Original semantics of fragments is to be short answers to various king of questions (“Who Did You Pass On The Road? Nobody”), but in general the grammar doesn't define semantics, and fragments are used by Lojbanists in various roles, e.g. in poetry. One kind of fragment is a bare terms sequence. We'll take the simplest term fragment, then, and interpret it as analogue of LA relational in it simplest pattern ([http://www.terjemar.net/relats2.php#la]):<br />
<br />
lo kabri<br />
la jacēla;<br />
"A bowl exists."<br />
<br />
Let us skip locatives for a moment and look at the other two patterns. Doesn't them remind you of anything? But of course!<br />
<br />
lo kabri po'u lo xunre<br />
la jacēla ñe janēla;<br />
"The bowl is the red thing."<br />
<br />
lo ka xunre po'e lo kabri<br />
"The redness belongs to the bowl."<br />
la jacēla pa annēla;<br />
"The bowl has redness."<br />
<br />
The equivalence pattern translation is very straighforward. The whole-part relationship is more complex; first note that {{vlapoi|ka}} abstraction take place of Kēlen's stative inflection. Also, relationship is reversed in Lojban, the main sumti being possessed and relative one, possessor. However, if we replace possession with association, the order could be made the same as in Kēlen:<br />
<br />
lo kabri pe lo ka xunre<br />
"The bowl is associated with the redness."<br />
<br />
Now, let's return to the locative. By another quirk of the grammar, relative phrases could be not just sumti, but tagged terms. And lo, sumti tensed by another sumti!<br />
<br />
lo kabri pe ga'u re'o lo jubme<br />
la jacēla sū jatēwa;<br />
"The bowl is on the table."<br />
<br />
Now to the other Kēlen relationals.<br />
<br />
ñi jacēla jahūwa;<br />
"The bowl is broken" or "The bowl broke." <br />
<br />
Simplest way of expressing change ([http://www.terjemar.net/relats2.php#ni]) I can think of is temporal tense. Now, pedantically, in Lojban tenses used as sumti tcita generally take {{vlapoi|nu}}-abstractons:<br />
<br />
lo kabri pe co'a lo za'i spofu<br />
"The bowl is beginning to be in broken state"<br />
<br />
However, maybe it could be idiomatically simplified (though motivation here is mostly to imitate Kēlen more closely):<br />
<br />
lo kabri po'u co'a lo spofu<br />
"The bowl is beginning to be broken thing"<br />
<br />
<br />
However, it is difficult to express agency in this way as easily as it is done in Kēlen.<br />
<br />
ñalla jacēla jahūwa;<br />
"I broke the bowl."<br />
<br />
Agency is naturally expressed in lojban with {{vlapoi|gau}}, which is modal formed from predicate {{vlapoi|gasnu}} - so note that we now introduce another way to use predicates in this staile, besides simple descriptions. One approach is add another relative phrase:<br />
<br />
lo kabri pe co'a lo za'i spofu pe gau mi<br />
"The bowl is associated with beginning of broken state, and this state is associated with me as agent."<br />
<br />
- but note that here second association is with the abstraction (state itself), and not with its beginning. Maybe it is more fitting to move the event contour inside description:<br />
<br />
lo kabri pe lo mu'e co'a spofu pe gau mi<br />
"The bowl is associated with beginning of broken condition, and this beginning is associated with me as agent."<br />
<br />
Or in identity pattern:<br />
<br />
lo kabri po'u lo co'a spofu pe gau mi<br />
"The bowl is starting-to-be-broken thing, which is associated with me as agent."<br />
<br />
<br />
However, in doing so, we moved dangerously close to have full-flanged predicate in relative phrase :)<br />
<br />
lo kabri pe lo mu'e gau mi co'a spofu<br />
"The bowl is associated with me causing beginning of broken condition."<br />
<br />
Kēlen ⟨ā⟩ and ⟨tō⟩ correspond to {{vlapoi|zu'e }} and {{vlapoi|bai}}:<br />
<br />
lo bisli po'u lo runme pe zu'e la solri<br />
ñamma anēlki ankehāri ā malō;<br />
"The Sun melted the ice."<br />
<br />
lo bisli po'u lo runme pe bai lo glanejni<br />
ñi anēlki ankehāri tō ancālli;<br />
"The heat melted the ice."<br />
<br />
Unfortunately, I cannot yet see the unified way to translate transaction relational ([http://www.terjemar.net/relats2.php#se]). For purely physical transaction, spatial tenses could be used, but in other types of transaction it would be too metaphorical for Lojban. The only approach I see now is to use various modals, which have two downsides: 1) for various kinds of transactions, various modals are used; and 2) in most typical cases, modal is reduplicated. E.g.:<br />
<br />
lo jdini pe va'u mi zi'e pe seva'u ko'a<br />
telme antēnni pē<br />
"I gave him some money."<br />
<br />
Here, {{vlapoi|va'u}} ({{vlapoi|xamgu}} modal) is used in place of {{vlapoi|dunda}}. Both sides of transaction represent the places of the same predicate, so its modal must be repeated two times in separate relative phrases.<br />
<br />
One could point that using {{vlapoi|xamgu}} for both sides of this kind of transaction is not very appropriate, as though x2 of xamgu is indeed one receiving the benefit, x1 is not source of the benefit, but the benefit itself. So, {lo jdini pe gau mi zi'e pe seva'u ko'a} might be more fitting. This argument shows yet another problem with this approach: connecting source and destination of transaction with {{vlapoi|zi'e}} creates no direct semantic link between them - in this case, the more direct translation should be "The money have me as agent and him as beneficiary", but it must be inferred that my agency is indeed the benifit of another person. This could be amended for in the same way as with NI relational:<br />
<br />
lo jdini pe seva'u ko'a pe gau mi<br />
<br />
However, this variant has a problem of {pe gau mi} associating with {ko'a} and not with the whole term, so perfect translation still not reached.<br />
<br />
Finally, PA relational([http://www.terjemar.net/relats2.php#pa]) is mostly shorthand for possessive pattern of LA, as noted in Kēlen grammar itself. It has additional meaning allowing abstractions to be possessors; but in Lojban it may be just expressed with (admittedly vague) {{vlapoi|pe}}:<br />
<br />
lo (ka/za'i)badri pe ko'a<br />
- or -<br />
ko'a po lo (ka/za'i) badri<br />
pa anlōrāl sāen;<br />
"She is grieving." (Lit: "Grief has her.")</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/sumti_staile&diff=119401User:Ramcinfo/sumti staile2016-03-09T13:57:11Z<p>Ramcinfo: </p>
<hr />
<div>(Please note that this draft requires at least passing knowledge of both Kēlen, a beautiful verbless conlang, and Lojban. Author hopes to write more in-depth introduction in future.)<br />
<br />
Imitating Kēlen in Lojban seems at first to be impossible, or at least, very awkward - after all, Lojban is built upon predicates, and predicates are often thought of as verbs (and adjectives). Most sumti, being descriptions, have a predicate in heart. On the other hand, if we consider simple descriptions of {lo broda} kind sort of atomic noun-like constructs, and look at Kēlen relationals as predicates, the task seems to be trivial. However, we can do better.<br />
<br />
First, note that grammar of Lojban allows fragments - predicate-less constructions which can pe used at the same level as usual statements. Original semantics of fragments is to be short answers to various king of questions (“Who Did You Pass On The Road? Nobody”), but in general the grammar doesn't define semantics, and fragments are used by Lojbanists in various roles, e.g. in poetry. One kind of fragment is a bare terms sequence. We'll take the simplest term fragment, then, and interpret it as analogue of LA relational in it simplest pattern ([http://www.terjemar.net/relats2.php#la]):<br />
<br />
lo kabri<br />
la jacēla;<br />
"A bowl exists."<br />
<br />
Let us skip locatives for a moment and look at the other two patterns. Doesn't them remind you of anything? But of course!<br />
<br />
lo kabri po'u lo xunre<br />
la jacēla ñe janēla;<br />
"The bowl is the red thing."<br />
<br />
lo ka xunre po'e lo kabri<br />
"The redness belongs to the bowl."<br />
la jacēla pa annēla;<br />
"The bowl has redness."<br />
<br />
The equivalence pattern translation is very straighforward. The whole-part relationship is more complex; first note that {{vlapoi|ka}} abstraction take place of Kēlen's stative inflection. Also, relationship is reversed in Lojban, the main sumti being possessed and relative one, possessor. However, if we replace possession with association, the order could be made the same as in Kēlen:<br />
<br />
lo kabri pe lo ka xunre<br />
"The bowl is associated with the redness."<br />
<br />
Now, let's return to the locative. By another quirk of the grammar, relative phrases could be not just sumti, but tagged terms. And lo, sumti tensed by another sumti!<br />
<br />
lo kabri pe ga'u re'o lo jubme<br />
la jacēla sū jatēwa;<br />
"The bowl is on the table."<br />
<br />
Now to the other Kēlen relationals.<br />
<br />
ñi jacēla jahūwa;<br />
"The bowl is broken" or "The bowl broke." <br />
<br />
Simplest way of expressing change ([http://www.terjemar.net/relats2.php#ni]) I can think of is temporal tense. Now, pedantically, in Lojban tenses used as sumti tcita generally take {{vlapoi|nu}}-abstractons:<br />
<br />
lo kabri pe co'a lo za'i spofu<br />
"The bowl is beginning to be in broken state"<br />
<br />
However, maybe it could be idiomatically simplified (though motivation here is mostly to imitate Kēlen more closely):<br />
<br />
lo kabri po'u co'a lo spofu<br />
"The bowl is beginning to be broken thing"<br />
<br />
<br />
However, it is difficult to express agency in this way as easily as it is done in Kēlen.<br />
<br />
ñalla jacēla jahūwa;<br />
"I broke the bowl."<br />
<br />
Agency is naturally expressed in lojban with {{vlapoi|gau}}, which is modal formed from predicate {{vlapoi|gasnu}} - so note that we now introduce another way to use predicates in this staile, besides simple descriptions. One approach is add another relative phrase:<br />
<br />
lo kabri pe co'a lo za'i spofu pe gau mi<br />
"The bowl is associated with beginning of broken state, and this state is associated with me as agent."<br />
<br />
- but note that here second association is with the abstraction (state itself), and not with its beginning. Maybe it is more fitting to move the event contour inside description:<br />
<br />
lo kabri pe lo mu'e co'a spofu pe gau mi<br />
"The bowl is associated with beginning of broken condition, and this beginning is associated with me as agent."<br />
<br />
Or in identity pattern:<br />
<br />
lo kabri po'u lo co'a spofu pe gau mi<br />
"The bowl is starting-to-be-broken thing, which is associated with me as agent."<br />
<br />
<br />
However, in doing so, we moved dangerously close to have full-flanged predicate in relative phrase :)<br />
<br />
lo kabri pe lo mu'e gau mi co'a spofu<br />
"The bowl is associated with me causing beginning of broken condition."<br />
<br />
Unfortunately, I cannot yet see the unified way to translate transaction relational ([http://www.terjemar.net/relats2.php#se]). For purely physical transaction, spatial tenses could be used, but in other types of transaction it would be too metaphorical for Lojban. The only approach I see now is to use various modals, which have two downsides: 1) for various kinds of transactions, various modals are used; and 2) in most typical cases, modal is reduplicated. E.g.:<br />
<br />
lo jdini pe va'u mi zi'e pe seva'u ko'a<br />
telme antēnni pē<br />
"I gave him some money."<br />
<br />
Here, {{vlapoi|va'u}} ({{vlapoi|xamgu}} modal) is used in place of {{vlapoi|dunda}}. Both sides of transaction represent the places of the same predicate, so its modal must be repeated two times in separate relative phrases.<br />
<br />
One could point that using {{vlapoi|xamgu}} for both sides of this kind of transaction is not very appropriate, as though x2 of xamgu is indeed one receiving the benefit, x1 is not source of the benefit, but the benefit itself. So, {lo jdini pe gau mi zi'e pe seva'u ko'a} might be more fitting. This argument shows yet another problem with this approach: connecting source and destination of transaction with {{vlapoi|zi'e}} creates no direct semantic link between them - in this case, the more direct translation should be "The money have me as agent and him as beneficiary", but it must be inferred that my agency is indeed the benifit of another person. This could be amended for in the same way as with NI relational:<br />
<br />
lo jdini pe seva'u ko'a pe gau mi<br />
<br />
However, this variant has a problem of {pe gau mi} associating with {ko'a} and not with the whole term, so perfect translation still not reached.<br />
<br />
Finally, PA relational([http://www.terjemar.net/relats2.php#pa]) is mostly shorthand for possessive pattern of LA, as noted in Kēlen grammar itself. It has additional meaning allowing abstractions to be possessors; but in Lojban it may be just expressed with (admittedly vague) {{vlapoi|pe}}:<br />
<br />
lo (ka/za'i)badri pe ko'a<br />
- or -<br />
ko'a po lo (ka/za'i) badri<br />
pa anlōrāl sāen;<br />
"She is grieving." (Lit: "Grief has her.")</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/sumti_staile&diff=119400User:Ramcinfo/sumti staile2016-03-09T13:27:42Z<p>Ramcinfo: </p>
<hr />
<div>(Please note that this draft requires at least passing knowledge of both Kēlen, a beautiful verbless conlang, and Lojban. Author hopes to write more in-depth introduction in future.)<br />
<br />
Imitating Kēlen in Lojban seems at first to be impossible, or at least, very awkward - after all, Lojban is built upon predicates, and predicates are often thought of as verbs (and adjectives). Most sumti, being descriptions, have a predicate in heart. On the other hand, if we consider simple descriptions of {lo broda} kind sort of atomic noun-like constructs, and look at Kēlen relationals as predicates, the task seems to be trivial. However, we can do better.<br />
<br />
First, note that grammar of Lojban allows fragments - predicate-less constructions which can pe used at the same level as usual statements. Original semantics of fragments is to be short answers to various king of questions (“Who Did You Pass On The Road? Nobody”), but in general the grammar doesn't define semantics, and fragments are used by Lojbanists in various roles, e.g. in poetry. One kind of fragment is a bare terms sequence. We'll take the simplest term fragment, then, and interpret it as analogue of LA relational in it simplest pattern ([http://www.terjemar.net/relats2.php#la]):<br />
<br />
lo kabri<br />
la jacēla;<br />
"A bowl exists."<br />
<br />
Let us skip locatives for a moment and look at the other two patterns. Doesn't them remind you of anything? But of course!<br />
<br />
lo kabri po'u lo xunre<br />
la jacēla ñe janēla;<br />
"The bowl is the red thing."<br />
<br />
lo ka xunre po'e lo kabri<br />
"The redness is belongs to the bowl."<br />
la jacēla pa annēla;<br />
"The bowl has redness."<br />
<br />
The equivalence pattern translation is very straighforward. The whole-part relationship is more complex; first note that {{vlapoi|ka}} abstraction take place of Kēlen's stative inflection. Also, relationship is reversed in Lojban, the main sumti being possessed and relative one, possessor. However, if we replace possession with association, the order could be made the same as in Kēlen:<br />
<br />
lo kabri pe lo ka xunre<br />
"The bowl is associated with the redness."<br />
<br />
Now, let's return to the locative. By another quirk of the grammar, relative phrases could be not just sumti, but tagged terms. And lo, sumti tensed by another sumti!<br />
<br />
lo kabri pe ga'u re'o lo jubme<br />
la jacēla sū jatēwa;<br />
"The bowl is on the table."<br />
<br />
Now to the other Kēlen relationals.<br />
<br />
ñi jacēla jahūwa;<br />
"The bowl is broken" or "The bowl broke." <br />
<br />
Simplest way of expressing change ([http://www.terjemar.net/relats2.php#ni]) I can think of is temporal tense. Now, pedantically, in Lojban tenses used as sumti tcita generally take {{vlapoi|nu}}-abstractons:<br />
<br />
lo kabri pe co'a lo za'i spofu<br />
"The bowl is beginning to be in broken state"<br />
<br />
However, maybe it could be idiomatically simplified (though motivation here is mostly to imitate Kēlen more closely):<br />
<br />
lo kabri po'u co'a lo spofu<br />
"The bowl is beginning to be broken thing"<br />
<br />
<br />
However, it is difficult to express agency in this way as easily as it is done in Kēlen.<br />
<br />
ñalla jacēla jahūwa;<br />
"I broke the bowl."<br />
<br />
Agency is naturally expressed in lojban with {{vlapoi|gau}}, which is modal formed from predicate {{vlapoi|gasnu}} - so note that we now introduce another way to use predicates in this staile, besides simple descriptions. One approach is add another relative phrase:<br />
<br />
lo kabri pe co'a lo za'i spofu pe gau mi<br />
"The bowl is associated with beginning of broken state, and this state is associated with me as agent."<br />
<br />
- but note that here second association is with the abstraction (state itself), and not with its beginning. Maybe it is more fitting to move the event contour inside description:<br />
<br />
lo kabri pe lo mu'e co'a spofu pe gau mi<br />
"The bowl is associated with beginning of broken condition, and this beginning is associated with me as agent."<br />
<br />
Or in identity pattern:<br />
<br />
lo kabri po'u lo co'a spofu pe gau mi<br />
"The bowl is starting-to-be-broken thing, which is associated with me as agent."<br />
<br />
<br />
However, in doing so, we moved dangerously close to have full-flanged predicate in relative phrase :)<br />
<br />
lo kabri pe lo mu'e gau mi co'a spofu<br />
"The bowl is associated with me causing beginning of broken condition."<br />
<br />
Unfortunately, I cannot yet see the unified way to translate transaction relational ([http://www.terjemar.net/relats2.php#se]). For purely physical transaction, spatial tenses could be used, but in other types of transaction it would be too metaphorical for Lojban. The only approach I see now is to use various modals, which have two downsides: 1) for various kinds of transactions, various modals are used; and 2) in most typical cases, modal is reduplicated. E.g.:<br />
<br />
lo jdini pe va'u mi zi'e pe seva'u ko'a<br />
telme antēnni pē<br />
"I gave him some money."<br />
<br />
Here, {{vlapoi|va'u}} ({{vlapoi|xamgu}} modal) is used in place of {{vlapoi|dunda}}. Both sides of transaction represent the places of the same predicate, so its modal must be repeated two times in separate relative phrases.<br />
<br />
One could point that using {{vlapoi|xamgu}} for both sides of this kind of transaction is not very appropriate, as though x2 of xamgu is indeed one receiving the benefit, x1 is not source of the benefit, but the benefit itself. So, {lo jdini pe gau mi zi'e pe seva'u ko'a} might be more fitting. This argument shows yet another problem with this approach: connecting source and destination of transaction with {{vlapoi|zi'e}} creates no direct semantic link between them - in this case, the more direct translation should be "The money have me as agent and him as beneficiary", but it must be inferred that my agency is indeed the benifit of another person. This could be amended for in the same way as with NI relational:<br />
<br />
lo jdini pe seva'u ko'a pe gau mi<br />
<br />
However, this variant has a problem of {pe gau mi} associating with {ko'a} and not with the whole term, so perfect translation still not reached.<br />
<br />
Finally, PA relational([http://www.terjemar.net/relats2.php#pa]) is mostly shorthand for possessive pattern of LA, as noted in Kēlen grammar itself. It has additional meaning allowing abstractions to be possessors; but in Lojban it may be just expressed with (admittedly vague) {{vlapoi|pe}}:<br />
<br />
lo (ka/za'i)badri pe ko'a<br />
- or -<br />
ko'a po lo (ka/za'i) badri<br />
pa anlōrāl sāen;<br />
"She is grieving." (Lit: "Grief has her.")</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/sumti_staile&diff=119399User:Ramcinfo/sumti staile2016-03-09T13:24:47Z<p>Ramcinfo: </p>
<hr />
<div>(Please note that this draft requires at least passing knowledge of both Kēlen, a beautiful verbless conlang, and Lojban. Author hopes to write more in-depth introduction in future.)<br />
<br />
Imitating Kēlen in Lojban seems at first to be impossible, or at least, very awkward - after all, Lojban is built upon predicates, and predicates are often thought of as verbs (and adjectives). Most sumti, being descriptions, have a predicate in heart. On the other hand, if we consider simple descriptions of {lo broda} kind sort of atomic noun-like constructs, and look at Kēlen relationals as predicates, the task seems to be trivial. However, we can do better.<br />
<br />
First, note that grammar of Lojban allows fragments - predicate-less constructions which can pe used at the same level as usual statements. Original semantics of fragments is to be short answers to various king of questions (“Who Did You Pass On The Road? Nobody”), but in general the grammar doesn't define semantics, and fragments are used by Lojbanists in various roles, e.g. in poetry. One kind of fragment is a bare terms sequence. We'll take the simplest term fragment, then, and interpret it as analogue of LA connective in it simplest pattern ([http://www.terjemar.net/relats2.php#la]):<br />
<br />
lo kabri<br />
la jacēla;<br />
"A bowl exists."<br />
<br />
Let us skip locatives for a moment and look at the other two patterns. Doesn't them remind you of anything? But of course!<br />
<br />
lo kabri po'u lo xunre<br />
la jacēla ñe janēla;<br />
"The bowl is the red thing."<br />
<br />
lo ka xunre po'e lo kabri<br />
"The redness is belongs to the bowl."<br />
la jacēla pa annēla;<br />
"The bowl has redness."<br />
<br />
The equivalence pattern translation is very straighforward. The whole-part relationship is more complex; first note that {{vlapoi|ka}} abstraction take place of Kēlen's stative inflection. Also, relationship is reversed in Lojban, the main sumti being possessed and relative one, possessor. However, if we replace possession with association, the order could be made the same as in Kēlen:<br />
<br />
lo kabri pe lo ka xunre<br />
"The bowl is associated with the redness."<br />
<br />
Now, let's return to the locative. By another quirk of the grammar, relative phrases could be not just sumti, but tagged terms. And lo, sumti tensed by another sumti!<br />
<br />
lo kabri pe ga'u re'o lo jubme<br />
la jacēla sū jatēwa;<br />
"The bowl is on the table."<br />
<br />
Now to the other Kēlen connectives.<br />
<br />
ñi jacēla jahūwa;<br />
"The bowl is broken" or "The bowl broke." <br />
<br />
Simplest way of expressing change ([http://www.terjemar.net/relats2.php#ni]) I can think of is temporal tense. Now, pedantically, in Lojban tenses used as sumti tcita generally take {{vlapoi|nu}}-abstractons:<br />
<br />
lo kabri pe co'a lo za'i spofu<br />
"The bowl is beginning to be in broken state"<br />
<br />
However, maybe it could be idiomatically simplified (though motivation here is mostly to imitate Kēlen more closely):<br />
<br />
lo kabri po'u co'a lo spofu<br />
"The bowl is beginning to be broken thing"<br />
<br />
<br />
However, it is difficult to express agency in this way as easily as it is done in Kēlen.<br />
<br />
ñalla jacēla jahūwa;<br />
"I broke the bowl."<br />
<br />
Agency is naturally expressed in lojban with {{vlapoi|gau}}, which is modal formed from predicate {{vlapoi|gasnu}} - so note that we now introduce another way to use predicates in this staile, besides simple descriptions. One approach is add another relative phrase:<br />
<br />
lo kabri pe co'a lo za'i spofu pe gau mi<br />
"The bowl is associated with beginning of broken state, and this state is associated with me as agent."<br />
<br />
- but note that here second association is with the abstraction (state itself), and not with its beginning. Maybe it is more fitting to move the event contour inside description:<br />
<br />
lo kabri pe lo mu'e co'a spofu pe gau mi<br />
"The bowl is associated with beginning of broken condition, and this beginning is associated with me as agent."<br />
<br />
Or in identity pattern:<br />
<br />
lo kabri po'u lo co'a spofu pe gau mi<br />
"The bowl is starting-to-be-broken thing, which is associated with me as agent."<br />
<br />
<br />
However, in doing so, we moved dangerously close to have full-flanged predicate in relative phrase :)<br />
<br />
lo kabri pe lo mu'e gau mi co'a spofu<br />
"The bowl is associated with me causing beginning of broken condition."<br />
<br />
Unfortunately, I cannot yet see the unified way to translate transaction connective ([http://www.terjemar.net/relats2.php#se]). For purely physical transaction, spatial tenses could be used, but in other types of transaction it would be too metaphorical for Lojban. The only approach I see now is to use various modals, which have two downsides: 1) for various kinds of transactions, various modals are used; and 2) in most typical cases, modal is reduplicated. E.g.:<br />
<br />
lo jdini pe va'u mi zi'e pe seva'u ko'a<br />
telme antēnni pē<br />
"I gave him some money."<br />
<br />
Here, {{vlapoi|va'u}} ({{vlapoi|xamgu}} modal) is used in place of {{vlapoi|dunda}}. Both sides of transaction represent the places of the same predicate, so its modal must be repeated two times in separate relative phrases.<br />
<br />
One could point that using {{vlapoi|xamgu}} for both sides of this kind of transaction is not very appropriate, as though x2 of xamgu is indeed one receiving the benefit, x1 is not source of the benefit, but the benefit itself. So, {lo jdini pe gau mi zi'e pe seva'u ko'a} might be more fitting. This argument shows yet another problem with this approach: connecting source and destination of transaction with {{vlapoi|zi'e}} creates no direct semantic link between them - in this case, the more direct translation should be "The money have me as agent and him as beneficiary", but it must be inferred that my agency is indeed the benifit of another person. This could be amended for in the same way as with NI connective:<br />
<br />
lo jdini pe seva'u ko'a pe gau mi<br />
<br />
However, this variant has a problem of {pe gau mi} associating with {ko'a} and not with the whole term, so perfect translation still not reached.<br />
<br />
Finally, PA connective ([http://www.terjemar.net/relats2.php#pa]) is mostly shorthand for possessive pattern of LA, as noted in Kēlen grammar itself. It has additional meaning allowing abstractions to be possessors; but in Lojban it may be just expressed with (admittedly vague) {{vlapoi|pe}}:<br />
<br />
lo (ka/za'i)badri pe ko'a<br />
- or -<br />
ko'a po lo (ka/za'i) badri<br />
pa anlōrāl sāen;<br />
"She is grieving." (Lit: "Grief has her.")</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/sumti_staile&diff=119396User:Ramcinfo/sumti staile2016-03-09T11:48:11Z<p>Ramcinfo: Created page with "(Please note that this draft require at least passing knowledge of both Kēlen, beautiful verbless conlang, and Lojban. Author hopes to write more in-depth introduction in fut..."</p>
<hr />
<div>(Please note that this draft require at least passing knowledge of both Kēlen, beautiful verbless conlang, and Lojban. Author hopes to write more in-depth introduction in future.)<br />
<br />
Imitating Kēlen in Lojban seems at first to be impossible, or at least, very awkward - after all, Lojban is built upon predicates, and predicates are often thought of as verbs (and adjectives). Most sumti, being descriptions, have a predicate in heart. On the other hand, if we consider simple descriptions of {lo broda} kind sort of atomic noun-like constructs, and look at Kēlen relationals as predicates, the task seems to be trivial. However, we can do better.<br />
<br />
First, note that grammar of Lojban allows fragments - predicate-less constructions which can pe used at the same level as usual statements. Original semantics of fragments is to be short answers to various king of questions (“Who Did You Pass On The Road? Nobody”), but in general the grammar doesn't define semantics, and fragments are used by Lojbanists in various roles, e.g. in poetry. One kind of fragment is a bare terms sequence. We'll take the simplest term fragment, then, and interpret it as analogue of LA connective in it simplest pattern ([http://www.terjemar.net/relats2.php#la]):<br />
<br />
lo kabri<br />
la jacēla;<br />
"A bowl exists."<br />
<br />
Let us skip locatives for a moment and look at the other two patterns. Doesn't them remind you of anything? But of course!<br />
<br />
lo kabri po'u lo xunre<br />
la jacēla ñe janēla;<br />
"The bowl is the red thing."<br />
<br />
lo ka xunre po'e lo kabri<br />
"The redness is belongs to the bowl."<br />
la jacēla pa annēla;<br />
"The bowl has redness."<br />
<br />
The equivalence pattern translation is very straighforward. The whole-part relationship is more complex; first note that {{vlapoi|ka}} abstraction take place of Kēlen's stative inflection. Also, relationship is reversed in Lojban, the main sumti being possessed and relative one, possessor. However, if we replace possession with association, the order could be made the same as in Kēlen:<br />
<br />
lo kabri pe lo ka xunre<br />
"The bowl is associated with the redness."<br />
<br />
Now, let's return to the locative. By another quirk of the grammar, relative phrases could be not just sumti, but tagged terms. And lo, sumti tensed by another sumti!<br />
<br />
lo kabri pe ga'u re'o lo jubme<br />
la jacēla sū jatēwa;<br />
"The bowl is on the table."<br />
<br />
Now to the other Kēlen connectives.<br />
<br />
ñi jacēla jahūwa;<br />
"The bowl is broken" or "The bowl broke." <br />
<br />
Simplest way of expressing change ([http://www.terjemar.net/relats2.php#ni]) I can think of is temporal tense. Now, pedantically, in Lojban tenses used as sumti tcita generally take {{vlapoi|nu}}-abstractons:<br />
<br />
lo kabri pe co'a lo za'i spofu<br />
"The bowl is beginning to be in broken state"<br />
<br />
However, maybe it could be idiomatically simplified (though motivation here is mostly to imitate Kēlen more closely):<br />
<br />
lo kabri po'u co'a lo spofu<br />
"The bowl is beginning to be broken thing"<br />
<br />
<br />
However, it is difficult to express agency in this way as easily as it is done in Kēlen.<br />
<br />
ñalla jacēla jahūwa;<br />
"I broke the bowl."<br />
<br />
Agency is naturally expressed in lojban with {{vlapoi|gau}}, which is modal formed from predicate {{vlapoi|gasnu}} - so note that we now introduce another way to use predicates in this staile, besides simple descriptions. One approach is add another relative phrase:<br />
<br />
lo kabri pe co'a lo za'i spofu pe gau mi<br />
"The bowl is associated with beginning of broken state, and this state is associated with me as agent."<br />
<br />
- but note that here second association is with the abstraction (state itself), and not with its beginning. Maybe it is more fitting to move the event contour inside description:<br />
<br />
lo kabri pe lo mu'e co'a spofu pe gau mi<br />
"The bowl is associated with beginning of broken condition, and this beginning is associated with me as agent."<br />
<br />
Or in identity pattern:<br />
<br />
lo kabri po'u lo co'a spofu pe gau mi<br />
"The bowl is starting-to-be-broken thing, which is associated with me as agent."<br />
<br />
<br />
However, in doing so, we moved dangerously close to have full-flanged predicate in relative phrase :)<br />
<br />
lo kabri pe lo mu'e gau mi co'a spofu<br />
"The bowl is associated with me causing beginning of broken condition."<br />
<br />
Unfortunately, I cannot yet see the unified way to translate transaction connective ([http://www.terjemar.net/relats2.php#se]). For purely physical transaction, spatial tenses could be used, but in other types of transaction it would be too metaphorical for Lojban. The only approach I see now is to use various modals, which have two downsides: 1) for various kinds of transactions, various modals are used; and 2) in most typical cases, modal is reduplicated. E.g.:<br />
<br />
lo jdini pe va'u mi zi'e pe seva'u ko'a<br />
telme antēnni pē<br />
"I gave him some money."<br />
<br />
Here, {{vlapoi|va'u}} ({{vlapoi|xamgu}} modal) is used in place of {{vlapoi|dunda}}. Both sides of transaction represent the places of the same predicate, so its modal must be repeated two times in separate relative phrases.<br />
<br />
One could point that using {{vlapoi|xamgu}} for both sides of this kind of transaction is not very appropriate, as though x2 of xamgu is indeed one receiving the benefit, x1 is not source of the benefit, but the benefit itself. So, {lo jdini pe gau mi zi'e pe seva'u ko'a} might be more fitting. This argument shows yet another problem with this approach: connecting source and destination of transaction with {{vlapoi|zi'e}} creates no direct semantic link between them - in this case, the more direct translation should be "The money have me as agent and him as beneficiary", but it must be inferred that my agency is indeed the benifit of another person. This could be amended for in the same way as with NI connective:<br />
<br />
lo jdini pe seva'u ko'a pe gau mi<br />
"The money are for benefit of him, by my agency".<br />
<br />
Finally, PA connective ([http://www.terjemar.net/relats2.php#pa]) is mostly shorthand for possessive pattern of LA, as noted in Kēlen grammar itself. It has additional meaning allowing abstractions to be possessors; but in Lojban it may be just expressed with (admittedly vague) {{vlapoi|pe}}:<br />
<br />
lo (ka/za'i)badri pe ko'a<br />
- or -<br />
ko'a po lo (ka/za'i) badri<br />
pa anlōrāl sāen;<br />
"She is grieving." (Lit: "Grief has her.")</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/lojbo_staile_liste&diff=119395User:Ramcinfo/lojbo staile liste2016-03-09T09:46:41Z<p>Ramcinfo: </p>
<hr />
<div>Principal purpose of this list is to explore ways to use Lojban different from Indo-European natlang ways.<br />
==Lojban-specific==<br />
* cmavo-only style<ref>[http://www.lojban.org/tiki/tiki-view_forum_thread.php?forumId=5&comments_parentId=7703&topics_offset=324&topics_sort_mode=lastPost_desc Lojban with only cmavo: an Oulipian strategy]</ref><br />
==Inspired by real language features==<br />
* {{vlapoi|sumcau|staile}}, inspired by nounless languages like that of Salishan and Wakashan families<ref>[https://www.dropbox.com/s/kvj63dtew6hs3z3/ENG%20Davidson%2CM.%20-%20Studies%20in%20southern%20Wakashan%20%28Nootkan%29%20grammar.pdf?dl=0 A grammar of Nootkah]</ref><ref>[https://en.wikipedia.org/wiki/Lojban#Syntax_and_semantics Example of Lojban imitating Nuu-chah-nulth] (near the end of the section). Note that it is also agglutinative.</ref>.<br />
==Inspired by other constructed languages==<br />
* Verbless style inspired by Kēlen<ref>[http://www.terjemar.net/grammar.php Kēlen Grammar]</ref>. See [[User:Ramcinfo/sumti_staile|the draft]].<br />
* toki pona style, with e.g. anaphora instead of nested constructs ({mi pinxe lo tcati .i mi masno lonu go'i}). Vocabulary might or might not be restricted.<br />
==Inspired by fictional languages==<br />
* Tlön styles, from Borges’ short story. Most Tlön languages lack nouns, so sumti are either avoided or thought of as combinations of properties and/or relations. {{jvs|za'a}} and {{jvs|si'au}} evidentials are common.<br />
:* snanu .utloine staile: in Southern Tlön style, meaning is constructed from verbs and adverbs. Example:<br />
{{mu|mo'i ga'u ku ti'a lo zu'o ru'i flecu cu co'a mluni}}<br />
:* berti .utloine staile: in Northern Tlön style, objects are referred to by combination of adjectives (qualities). Possible lojbanic ways to do so: {{jvs|ka}} and {{jvs|za'i}} abstractions, modals making main level bridi into such abstractions (especially {{vlapoi|kai|ku}} and {{vlapoi|ri'i|ku}}, also {{vlapoi|ci'o|ku}} and {{vlapoi|mu'u|ku}}), {{vlapoi|ca'o|nai}} and {{vlapoi|co'i|nai}} event contours, {{jvs|ru'i}} and {{jvs|ze'e}} interval properties. Example:<br />
{{mu|kai vacri je gusni ne'i lo kai'u narju je kandi je tsani}}<br />
<br />
<br />
{{notci|Note: I am tempted to replace {lo zu'o} and {lo kai'u} with something other in these examples, to completely avoid references to (non-abstract) objects.}}<br />
* melaxoxengron staile, inspired by “language of dreams” in Max Frei novels. Similar to (especially Northern) Tlön style; default evidential is {{jvs|si'au}}, {{jvs|se'o}} may also be used.<br />
==Inspired by programming languages==<br />
* {{vlapoi|minde|sampla|staile}}, corresponding to imperative programming paradigm. Instead of claims, predicates are understood as commands. Some attempts are done here: [[Writing algorithms in Lojban]].<br />
* {{vlapoi|fancu|sampla|staile}}, corresponding to functional -"- -"- . Selbri understood as functions. See [[User:Ramcinfo/fancu_staile|the draft]].<br />
* {{vlapoi|logji|sampla|staile}}, corresponding to logical -"- -"- . Early draft is [[User:Ramcinfo/logji_staile|here]]. See also la jimpe<ref>http://web.mit.edu/~rspeer/Public/jimpe.pdf</ref>.<br />
* {{vlapoi|tinsa|tectaipe|staile}}, corresponding to strict typing.<br />
==Miscellaneous==<br />
* Stack staile, based on proglangs like Forth and PostScript and conlangs like [[Fith]] and Nalnuàntir<ref>http://conlang.wikia.com/wiki/Nalnu%C3%A0ntir</ref><br />
* Improvements of mekso, e.g. fancu bridi mekso proposal<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref><br />
=Credits=<br />
Many ideas were proposed by [[la gleki]].<br />
=References=<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=la_vlasisku&diff=117972la vlasisku2015-10-25T10:16:36Z<p>Ramcinfo: </p>
<hr />
<div>A frontend to [[jbovlaste]] dictionary.<br />
*[http://vlasisku.lojban.org/vlasisku/ English database]<br />
<br />
[[Category:vlaste saske]]</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/scope_study&diff=117965User:Ramcinfo/scope study2015-10-23T17:17:36Z<p>Ramcinfo: /* Followup */</p>
<hr />
<div>Scope operators are things that modify predications as a whole (bridi operators) or predicates (selbri operators). They are: tenses, some modals, {na} negation, outer quantifiers, and connectives. They are called scope operators because when multiple are present in the same bridi, they modify the bridi in the order based on their order in the bridi text.<br />
<br />
== Tenses and modals ==<br />
When one operator modifies the result of another, it is said for latter to be in the scope of former.<ref>http://lojban.github.io/cll/10/13/, example 13.7</ref><br />
<br />
[va'o ti] [ba] culno fa lo kabri [se va'u mi]<br />
<br />
Linking operator to selbri with {be} allows to incorporate it into the selbri. It acts on selbri only, producing new, modified selbri, so it scopes after all other operators (and even after regular sumti, in a way).<br />
<br />
[va'o ti] [ba] cunlo ⟨be di'a⟩ fa lo kabri [se va'u mi]<br />
<br />
Another way to incorporate an operator into selbri is {jai}-conversion. Such a link will have scope below operators linked with {be}, if any:<br />
<br />
ma [va'o ti] [ba] ⟨jai gau⟩ cunlo ⟨be di'a⟩ fai lo kabri [se va'u mi]<br />
<br />
The order of bridi operators relative to other parts of bridi (being selbri and sumti) is irrelevant. Let us move them all in front of bridi. (We're adding {ku} to {ba} to turn it into sumti tcita from selbri tcita, so it could be an independent term.)<br />
<br />
[va'o ti] [ba ku] [se va'u mi] (⟨di'a ku⟩ ⟨gau ma⟩ culno) fa lo kabri<br />
<br />
The operators modify the meaning of the sumti in this way:<br />
<br />
(va'o ti (ba ku (se va'u mi ((di'a ku (gau ma (culno))) fa lo kabri))))<br />
<br />
or using composition and reverse-apply operators:<br />
<br />
(va'o ti ∘ ba ku ∘ se va'u mi)(d'a ku ∘ gau ma ∘ culno)(fa lo kabri)<br />
<br />
The following happens in present context:<br />
The following happens in the future:<br />
The following happens for me:<br />
The thing is a cup<br />
This is done again:<br />
This is done by whom, I want to know.<br />
The thing is full.<br />
<br />
<br />
It should be noted what a tense stating both direction and interval is one operator; and in fact such tenses give their component in order reverse to the order of operators, e.g. {puzi} is equivalent to {ziku puku}.<br />
<br />
== Quantifiers ==<br />
<br />
{na}, absent in the example above, behaves the same way, as do outer quantifiers — except the latter create {da}* variables behind the scene:<br />
<br />
mi na pendo ci gerku => [na ku] [ci da poi gerku] zo'u mi pendo da<br />
<br />
"It is not true what each of four dogs is my pet"<br />
<br />
mi pendo ci gerku naku => [ci da poi gerku] [na ku] zo'u mi pendo da<br />
<br />
"For each of four dogs, it is not true what it is my pet"<br />
(e.g. no one of four dogs is my pet)<br />
<br />
== Connectives ==<br />
<br />
Logical connectives could be reduced to outer quantifiers, but it easier to expand them to bridi connectives. For latter, scope of operator inside first connected bridi ends at the end of the bridi, before the connective:<br />
<br />
(mi [na] sipta'i) .ije (mi gleki)<br />
<br />
"I am not sleepy. And I am happy"<br />
<br />
Scope of any operator could be extended to the connected predicates through common prenex:<br />
<br />
[naku] zo'u (mi sipta'i) .ije (mi gleki)<br />
<br />
"It is not true what (I am sleepy and I am happy)"<br />
<br />
Other connectives are expanded to bridi connectives:<br />
<br />
mi [na] (sipta'i) je (gleki) => [na] zo'u (mi sipta'i) .ije (mi gleki)<br />
mi (sipta'i) je (gleki) naku => (mi sipta'i [naku]) .ije (mi gleki [naku])<br />
<br />
mi [na] (sipta'i) gi'e (gleki) => (mi [na] sipta'i) .ije (mi gleki)<br />
mi [naku] (sipta'i) gi'e (gleki) => [naku] zo'u (mi sipta'i) .ije (mi gleki)<br />
mi (sipta'i) gi'e (gleki [naku]) => (mi sipta'i) .ije (mi gleki [naku])<br />
mi (sipta'i) gi'e (gleki vau) [naku] => (mi sipta'i [naku]) .ije (mi gleki [naku])<br />
<br />
mi .e do [na] sipta'i => (mi [na] sipta'i) .ije (do [na] sipta'i)<br />
naku mi .e do sipta'i => [naku] zo'u (mi sipta'i) .ije (mi gleki)<br />
<br />
== Todo ==<br />
<br />
* Rewrite more clearly.<br />
* Review with other Lojbanists.<br />
<br />
== Credits ==<br />
Study done with the help of omni___, xorxes, Ilmen, gleki and latro`a; and maybe someone I forgot to mention — sorry, then.<br />
<br />
== Followup ==<br />
This study is close to la tersmu predicate logic analysis, but diverges from it in some points.<br />
<br />
[va'o ti] [ba] culno fa lo kabri [se va'u mi]<br />
<br />
kabri(c0)<br />
(va'o)(ti). (ba)(). (se va'u)(mi). culno(c0)<br />
<br />
cy no kabri<br />
.i [va'o ti] [ba ku] [se va'u mi] zo'u cy no culno<br />
<br />
Fisrt, la tersmu doesn't distinguish modification of selbri with {be} from modification of bridi with sumti-tags; both threated as modification of bridi, and scoped in order of appearance:<br />
<br />
[va'o ti] [ba] cunlo ⟨be di'a⟩ fa lo kabri [se va'u mi]<br />
<br />
kabri(c0)<br />
(va'o)(ti). (ba)(). (di'a)() (se va'u)(mi). culno(c0)<br />
<br />
cy no kabri<br />
.i [va'o ti] [ba ku] ⟨di'a ku⟩ [se va'u mi] zo'u cy no culno<br />
<br />
{jai}-conversion, on the other hand, scopes last, after all other modification, but still modifies the whole bridi:<br />
<br />
⟨ma⟩ [va'o ti] [ba] ⟨jai gau⟩ cunlo ⟨be di'a⟩ fai lo kabri [se va'u mi]<br />
<br />
kabri(c0)<br />
? x1. (va'o)(ti). (ba)(). (di'a)(). (se va'u)(mi). (gau)(x1). cunlo(c0)<br />
<br />
cy no kabri<br />
.i ma goi ko'a [va'o ti] [ba ku] ⟨di'a ku⟩ [se va'u mi] ⟨gau ko'a⟩ zo'u cy no culno<br />
<br />
Compare with my analysis:<br />
<br />
[va'o ti] [ba ku] [se va'u mi] (⟨di'a ku⟩ ⟨gau ma⟩ culno) fa lo kabri<br />
<br />
Second, there is slight difference in analysis of {na}: if it scopes last, la tersmu doesn't place it in prenex:<br />
<br />
na ku va'o ti broda<br />
<br />
!(va'o)(ti). broda( )<br />
<br />
na ku va'o ti zo'u broda<br />
<br />
but:<br />
<br />
va'o ti na ku broda<br />
<br />
(va'o)(ti). !broda( )<br />
<br />
va'o ti zo'u na ku broda<br />
<br />
Finally, la tersmu doesn't handle scopes of connectives:<br />
<br />
mi [na] (sipta'i) je (gleki)<br />
<br />
!<sipta'i(_)){je}<gleki(_)>(mi)<br />
<br />
[na ku] mi (ke sipta'i ke'e) je (ke gleki ke'e)<br />
<br />
gives same result as:<br />
<br />
mi (sipta'i) je (gleki) naku<br />
<br />
!<sipta'i(_)){je}<gleki(_)>(mi)<br />
<br />
[na ku] mi (ke sipta'i ke'e) je (ke gleki ke'e)</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/scope_study&diff=117964User:Ramcinfo/scope study2015-10-23T17:07:13Z<p>Ramcinfo: la tersmu comparison</p>
<hr />
<div>Scope operators are things that modify predications as a whole (bridi operators) or predicates (selbri operators). They are: tenses, some modals, {na} negation, outer quantifiers, and connectives. They are called scope operators because when multiple are present in the same bridi, they modify the bridi in the order based on their order in the bridi text.<br />
<br />
== Tenses and modals ==<br />
When one operator modifies the result of another, it is said for latter to be in the scope of former.<ref>http://lojban.github.io/cll/10/13/, example 13.7</ref><br />
<br />
[va'o ti] [ba] culno fa lo kabri [se va'u mi]<br />
<br />
Linking operator to selbri with {be} allows to incorporate it into the selbri. It acts on selbri only, producing new, modified selbri, so it scopes after all other operators (and even after regular sumti, in a way).<br />
<br />
[va'o ti] [ba] cunlo ⟨be di'a⟩ fa lo kabri [se va'u mi]<br />
<br />
Another way to incorporate an operator into selbri is {jai}-conversion. Such a link will have scope below operators linked with {be}, if any:<br />
<br />
ma [va'o ti] [ba] ⟨jai gau⟩ cunlo ⟨be di'a⟩ fai lo kabri [se va'u mi]<br />
<br />
The order of bridi operators relative to other parts of bridi (being selbri and sumti) is irrelevant. Let us move them all in front of bridi. (We're adding {ku} to {ba} to turn it into sumti tcita from selbri tcita, so it could be an independent term.)<br />
<br />
[va'o ti] [ba ku] [se va'u mi] (⟨di'a ku⟩ ⟨gau ma⟩ culno) fa lo kabri<br />
<br />
The operators modify the meaning of the sumti in this way:<br />
<br />
(va'o ti (ba ku (se va'u mi ((di'a ku (gau ma (culno))) fa lo kabri))))<br />
<br />
or using composition and reverse-apply operators:<br />
<br />
(va'o ti ∘ ba ku ∘ se va'u mi)(d'a ku ∘ gau ma ∘ culno)(fa lo kabri)<br />
<br />
The following happens in present context:<br />
The following happens in the future:<br />
The following happens for me:<br />
The thing is a cup<br />
This is done again:<br />
This is done by whom, I want to know.<br />
The thing is full.<br />
<br />
<br />
It should be noted what a tense stating both direction and interval is one operator; and in fact such tenses give their component in order reverse to the order of operators, e.g. {puzi} is equivalent to {ziku puku}.<br />
<br />
== Quantifiers ==<br />
<br />
{na}, absent in the example above, behaves the same way, as do outer quantifiers — except the latter create {da}* variables behind the scene:<br />
<br />
mi na pendo ci gerku => [na ku] [ci da poi gerku] zo'u mi pendo da<br />
<br />
"It is not true what each of four dogs is my pet"<br />
<br />
mi pendo ci gerku naku => [ci da poi gerku] [na ku] zo'u mi pendo da<br />
<br />
"For each of four dogs, it is not true what it is my pet"<br />
(e.g. no one of four dogs is my pet)<br />
<br />
== Connectives ==<br />
<br />
Logical connectives could be reduced to outer quantifiers, but it easier to expand them to bridi connectives. For latter, scope of operator inside first connected bridi ends at the end of the bridi, before the connective:<br />
<br />
(mi [na] sipta'i) .ije (mi gleki)<br />
<br />
"I am not sleepy. And I am happy"<br />
<br />
Scope of any operator could be extended to the connected predicates through common prenex:<br />
<br />
[naku] zo'u (mi sipta'i) .ije (mi gleki)<br />
<br />
"It is not true what (I am sleepy and I am happy)"<br />
<br />
Other connectives are expanded to bridi connectives:<br />
<br />
mi [na] (sipta'i) je (gleki) => [na] zo'u (mi sipta'i) .ije (mi gleki)<br />
mi (sipta'i) je (gleki) naku => (mi sipta'i [naku]) .ije (mi gleki [naku])<br />
<br />
mi [na] (sipta'i) gi'e (gleki) => (mi [na] sipta'i) .ije (mi gleki)<br />
mi [naku] (sipta'i) gi'e (gleki) => [naku] zo'u (mi sipta'i) .ije (mi gleki)<br />
mi (sipta'i) gi'e (gleki [naku]) => (mi sipta'i) .ije (mi gleki [naku])<br />
mi (sipta'i) gi'e (gleki vau) [naku] => (mi sipta'i [naku]) .ije (mi gleki [naku])<br />
<br />
mi .e do [na] sipta'i => (mi [na] sipta'i) .ije (do [na] sipta'i)<br />
naku mi .e do sipta'i => [naku] zo'u (mi sipta'i) .ije (mi gleki)<br />
<br />
== Todo ==<br />
<br />
* Rewrite more clearly.<br />
* Review with other Lojbanists.<br />
<br />
== Credits ==<br />
Study done with the help of omni___, xorxes, Ilmen, gleki and latro`a; and maybe someone I forgot to mention — sorry, then.<br />
<br />
== Followup ==<br />
This study is close to la tersmu predicate logic analysis, but diverges from it in some points.<br />
<br />
[va'o ti] [ba] culno fa lo kabri [se va'u mi]<br />
<br />
kabri(c0)<br />
(va'o)(ti). (ba)(). (se va'u)(mi). culno(c0)<br />
<br />
<br />
cy no kabri<br />
.i [va'o ti] [ba ku] [se va'u mi] zo'u cy no culno<br />
<br />
Fisrt, la tersmu doesn't distinguish modification of selbri with {be} from modification of bridi with sumti-tags; both threated as modification of bridi, and scoped in order of appearance:<br />
<br />
[va'o ti] [ba] cunlo ⟨be di'a⟩ fa lo kabri [se va'u mi]<br />
<br />
kabri(c0)<br />
(va'o)(ti). (ba)(). (di'a)() (se va'u)(mi). culno(c0)<br />
<br />
cy no kabri<br />
.i [va'o ti] [ba ku] ⟨di'a ku⟩ [se va'u mi] zo'u cy no culno<br />
<br />
{jai}-conversion, on the other hand, scopes last, after all other modification, but still modifies the whole bridi:<br />
<br />
⟨ma⟩ [va'o ti] [ba] ⟨jai gau⟩ cunlo ⟨be di'a⟩ fai lo kabri [se va'u mi]<br />
<br />
kabri(c0)<br />
? x1. (va'o)(ti). (ba)(). (di'a)(). (se va'u)(mi). (gau)(x1). cunlo(c0)<br />
<br />
cy no kabri<br />
.i ma goi ko'a [va'o ti] [ba ku] ⟨di'a ku⟩ [se va'u mi] ⟨gau ko'a⟩ zo'u cy no culno<br />
<br />
Compare with my analysis:<br />
<br />
[va'o ti] [ba ku] [se va'u mi] (⟨di'a ku⟩ ⟨gau ma⟩ culno) fa lo kabri<br />
<br />
Second, there is slight difference in analysis of {na}: if it scopes last, la tersmu doesn't place it in prenex:<br />
<br />
na ku va'o ti broda<br />
<br />
!(va'o)(ti). broda( )<br />
<br />
na ku va'o ti zo'u broda<br />
<br />
but:<br />
<br />
va'o ti na ku broda<br />
<br />
(va'o)(ti). !broda( )<br />
<br />
va'o ti zo'u na ku broda<br />
<br />
Finally, la tersmu doesn't handle scopes of connectives:<br />
<br />
mi [na] (sipta'i) je (gleki)<br />
<br />
!<sipta'i(_)){je}<gleki(_)>(mi)<br />
<br />
[na ku] mi (ke sipta'i ke'e) je (ke gleki ke'e)<br />
<br />
gives same result as:<br />
<br />
mi (sipta'i) je (gleki) naku<br />
<br />
!<sipta'i(_)){je}<gleki(_)>(mi)<br />
<br />
[na ku] mi (ke sipta'i ke'e) je (ke gleki ke'e)</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117629User:Ramcinfo/fancu staile2015-09-21T12:24:27Z<p>Ramcinfo: /* Notes */</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {ka}:<br />
lo goi la xunre xiky ge'u ka [ce'u] klesi [ce'u] fi lo ka xunre kei kei<br />
// var redFilter = function (sample) { return filter(sample, red); }; <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
Or with {emna}:<br />
<br />
'''lo''' se.emna '''be''' la ''fancu'' '''bei''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' se.emna la ''fancu'' ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' se.emna la ''fancu'' ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' se.emna la ''fancu'' ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== Comparison with Ross Ogilvie's system ==<br />
Ross Ogilvie presents a proposal for reformation of mex<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref> with some very similar ideas. Here's comparation of his notation with one used here:<br />
<br />
<br />
{| class="wikitable"<br />
|+ fancu staile/fancu bridi mekso comparison<br />
! operation !! Ramcinfo !! Ross Ogilvie<br />
|-<br />
| return value || no special notation<sup>*</sup>, ce'u, ke'a || ce'au<sup>‡</sup><br />
|-<br />
| variable binding || ce'ai<sup>†</sup> || zo'ai<sup>‡</sup> ({ce'ai} is also considered)<br />
|-<br />
| convert function bridi (definition) to sumti (first-class function value) || lo ka || xau<sup>‡</sup> ({ni}, {du'u} and {su'u} are also considered)<br />
|-<br />
| convert function bridi to sumti (result of function application) || lo kai'u<sup>†</sup> (ce'u) / lo'oi<sup>†</sup> (ke'a) || also {xau}<br />
|-<br />
| convert function selbri to sumti (using functions as arguments) || me'ei<sup>†</sup> || ni'e<br />
|-<br />
| convert function sumti to selbri || me'au<sup>†</sup> || me<br />
|-<br />
| partial application || kai'u<sup>†</sup> || be'ei<sup>‡</sup><br />
|-<br />
| function composition || la finti<sup>‡</sup> || fancyjo'e<sup>‡</sup><br />
|-<br />
| curry || la karis.<sup>‡</sup> || na'u<sup>‡</sup><br />
|-<br />
| uncurry || - || nu'a<sup>‡</sup><br />
|-<br />
| list constructor || la zbasu<sup>‡</sup> || ce'o<br />
|-<br />
| map || - || porkanji<sup>‡</sup><br />
|-<br />
| fold || - || porjmina<sup>‡</sup><br />
|-<br />
| filter || klesi || -<br />
|}<br />
<br />
<sup>*</sup> {la jalge} is used for an bound variable argument intended as a return value, but that's pure convention. In Ramcinfo's approach, any bound variable of selbri could be used as argument or return value as needed.<br />
<br />
<sup>†</sup> Experimental<br />
<br />
<sup>‡</sup> Proposed or re-purposed specially for use in these systems<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117628User:Ramcinfo/fancu staile2015-09-21T12:19:17Z<p>Ramcinfo: /* Notes */</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {ka}:<br />
lo goi la xunre xiky ge'u ka [ce'u] klesi [ce'u] fi lo ka xunre kei kei<br />
// var redFilter = function (sample) { return filter(sample, red); }; <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
la ''fancu'' cu '''emna''' ''la sumti'' ''la sumti''<br />
<br />
== Comparison with Ross Ogilvie's system ==<br />
Ross Ogilvie presents a proposal for reformation of mex<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref> with some very similar ideas. Here's comparation of his notation with one used here:<br />
<br />
<br />
{| class="wikitable"<br />
|+ fancu staile/fancu bridi mekso comparison<br />
! operation !! Ramcinfo !! Ross Ogilvie<br />
|-<br />
| return value || no special notation<sup>*</sup>, ce'u, ke'a || ce'au<sup>‡</sup><br />
|-<br />
| variable binding || ce'ai<sup>†</sup> || zo'ai<sup>‡</sup> ({ce'ai} is also considered)<br />
|-<br />
| convert function bridi (definition) to sumti (first-class function value) || lo ka || xau<sup>‡</sup> ({ni}, {du'u} and {su'u} are also considered)<br />
|-<br />
| convert function bridi to sumti (result of function application) || lo kai'u<sup>†</sup> (ce'u) / lo'oi<sup>†</sup> (ke'a) || also {xau}<br />
|-<br />
| convert function selbri to sumti (using functions as arguments) || me'ei<sup>†</sup> || ni'e<br />
|-<br />
| convert function sumti to selbri || me'au<sup>†</sup> || me<br />
|-<br />
| partial application || kai'u<sup>†</sup> || be'ei<sup>‡</sup><br />
|-<br />
| function composition || la finti<sup>‡</sup> || fancyjo'e<sup>‡</sup><br />
|-<br />
| curry || la karis.<sup>‡</sup> || na'u<sup>‡</sup><br />
|-<br />
| uncurry || - || nu'a<sup>‡</sup><br />
|-<br />
| list constructor || la zbasu<sup>‡</sup> || ce'o<br />
|-<br />
| map || - || porkanji<sup>‡</sup><br />
|-<br />
| fold || - || porjmina<sup>‡</sup><br />
|-<br />
| filter || klesi || -<br />
|}<br />
<br />
<sup>*</sup> {la jalge} is used for an bound variable argument intended as a return value, but that's pure convention. In Ramcinfo's approach, any bound variable of selbri could be used as argument or return value as needed.<br />
<br />
<sup>†</sup> Experimental<br />
<br />
<sup>‡</sup> Proposed or re-purposed specially for use in these systems<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117627User:Ramcinfo/fancu staile2015-09-21T12:18:49Z<p>Ramcinfo: </p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {ka}:<br />
lo goi la xunre xiky ge'u ka [ce'u] klesi [ce'u] fi lo ka xunre kei kei<br />
// var redFilter = function (sample) { return filter(sample, red); }; <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
la ''fancu'' '''emna''' ''la sumti'' ''la sumti''<br />
<br />
== Comparison with Ross Ogilvie's system ==<br />
Ross Ogilvie presents a proposal for reformation of mex<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref> with some very similar ideas. Here's comparation of his notation with one used here:<br />
<br />
<br />
{| class="wikitable"<br />
|+ fancu staile/fancu bridi mekso comparison<br />
! operation !! Ramcinfo !! Ross Ogilvie<br />
|-<br />
| return value || no special notation<sup>*</sup>, ce'u, ke'a || ce'au<sup>‡</sup><br />
|-<br />
| variable binding || ce'ai<sup>†</sup> || zo'ai<sup>‡</sup> ({ce'ai} is also considered)<br />
|-<br />
| convert function bridi (definition) to sumti (first-class function value) || lo ka || xau<sup>‡</sup> ({ni}, {du'u} and {su'u} are also considered)<br />
|-<br />
| convert function bridi to sumti (result of function application) || lo kai'u<sup>†</sup> (ce'u) / lo'oi<sup>†</sup> (ke'a) || also {xau}<br />
|-<br />
| convert function selbri to sumti (using functions as arguments) || me'ei<sup>†</sup> || ni'e<br />
|-<br />
| convert function sumti to selbri || me'au<sup>†</sup> || me<br />
|-<br />
| partial application || kai'u<sup>†</sup> || be'ei<sup>‡</sup><br />
|-<br />
| function composition || la finti<sup>‡</sup> || fancyjo'e<sup>‡</sup><br />
|-<br />
| curry || la karis.<sup>‡</sup> || na'u<sup>‡</sup><br />
|-<br />
| uncurry || - || nu'a<sup>‡</sup><br />
|-<br />
| list constructor || la zbasu<sup>‡</sup> || ce'o<br />
|-<br />
| map || - || porkanji<sup>‡</sup><br />
|-<br />
| fold || - || porjmina<sup>‡</sup><br />
|-<br />
| filter || klesi || -<br />
|}<br />
<br />
<sup>*</sup> {la jalge} is used for an bound variable argument intended as a return value, but that's pure convention. In Ramcinfo's approach, any bound variable of selbri could be used as argument or return value as needed.<br />
<br />
<sup>†</sup> Experimental<br />
<br />
<sup>‡</sup> Proposed or re-purposed specially for use in these systems<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117626User:Ramcinfo/fancu staile2015-09-21T09:01:14Z<p>Ramcinfo: /* Comparison with Ross Ogilvie's system */</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {ka}:<br />
lo goi la xunre xiky ge'u ka [ce'u] klesi [ce'u] fi lo ka xunre kei kei<br />
// var redFilter = function (sample) { return filter(sample, red); }; <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== Comparison with Ross Ogilvie's system ==<br />
Ross Ogilvie presents a proposal for reformation of mex<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref> with some very similar ideas. Here's comparation of his notation with one used here:<br />
<br />
<br />
{| class="wikitable"<br />
|+ fancu staile/fancu bridi mekso comparison<br />
! operation !! Ramcinfo !! Ross Ogilvie<br />
|-<br />
| return value || no special notation<sup>*</sup>, ce'u, ke'a || ce'au<sup>‡</sup><br />
|-<br />
| variable binding || ce'ai<sup>†</sup> || zo'ai<sup>‡</sup> ({ce'ai} is also considered)<br />
|-<br />
| convert function bridi (definition) to sumti (first-class function value) || lo ka || xau<sup>‡</sup> ({ni}, {du'u} and {su'u} are also considered)<br />
|-<br />
| convert function bridi to sumti (result of function application) || lo kai'u<sup>†</sup> (ce'u) / lo'oi<sup>†</sup> (ke'a) || also {xau}<br />
|-<br />
| convert function selbri to sumti (using functions as arguments) || me'ei<sup>†</sup> || ni'e<br />
|-<br />
| convert function sumti to selbri || me'au<sup>†</sup> || me<br />
|-<br />
| partial application || kai'u<sup>†</sup> || be'ei<sup>‡</sup><br />
|-<br />
| function composition || la finti<sup>‡</sup> || fancyjo'e<sup>‡</sup><br />
|-<br />
| curry || la karis.<sup>‡</sup> || na'u<sup>‡</sup><br />
|-<br />
| uncurry || - || nu'a<sup>‡</sup><br />
|-<br />
| list constructor || la zbasu<sup>‡</sup> || ce'o<br />
|-<br />
| map || - || porkanji<sup>‡</sup><br />
|-<br />
| fold || - || porjmina<sup>‡</sup><br />
|-<br />
| filter || klesi || -<br />
|}<br />
<br />
<sup>*</sup> {la jalge} is used for an bound variable argument intended as a return value, but that's pure convention. In Ramcinfo's approach, any bound variable of selbri could be used as argument or return value as needed.<br />
<br />
<sup>†</sup> Experimental<br />
<br />
<sup>‡</sup> Proposed or re-purposed specially for use in these systems<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117625User:Ramcinfo/fancu staile2015-09-21T00:13:02Z<p>Ramcinfo: /* Comparison with Ross Ogilvie's system */</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {ka}:<br />
lo goi la xunre xiky ge'u ka [ce'u] klesi [ce'u] fi lo ka xunre kei kei<br />
// var redFilter = function (sample) { return filter(sample, red); }; <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== Comparison with Ross Ogilvie's system ==<br />
Ross Ogilvie presents a proposal for reformation of mex<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref> with some very similar ideas. Here's comparation of his notation with one used here:<br />
<br />
<br />
{| class="wikitable"<br />
|+ fancu staile/fancu bridi mekso comparison<br />
! operation !! Ramcinfo !! Ross Ogilvie<br />
|-<br />
| return value || no special notation<sup>*</sup>, ce'u, ke'a || ce'au<sup>‡</sup><br />
|-<br />
| variable binding || ce'ai<sup>†</sup> || zo'ai<sup>‡</sup> ({ce'ai} is also considered)<br />
|-<br />
| convert function bridi (definition) to sumti (first-class function value) || ka || xau<sup>‡</sup> ({ni}, {du'u} and {su'u} are also considered)<br />
|-<br />
| convert function bridi to sumti (result of function application) || lo kai'u<sup>†</sup> (ce'u) / lo'oi<sup>†</sup> (ke'a) || also {xau}<br />
|-<br />
| convert function selbri to sumti (using functions as arguments) || me'ei<sup>†</sup> || ni'e<br />
|-<br />
| convert function sumti to selbri || me'au<sup>†</sup> || me<br />
|-<br />
| partial application || kai'u<sup>†</sup> || be'ei<sup>‡</sup><br />
|-<br />
| function composition || la finti<sup>‡</sup> || fancyjo'e<sup>‡</sup><br />
|-<br />
| curry || la karis.<sup>‡</sup> || na'u<sup>‡</sup><br />
|-<br />
| uncurry || - || nu'a<sup>‡</sup><br />
|-<br />
| list constructor || la zbasu<sup>‡</sup> || ce'o<br />
|-<br />
| map || - || porkanji<sup>‡</sup><br />
|-<br />
| fold || - || porjmina<sup>‡</sup><br />
|-<br />
| filter || klesi || -<br />
|}<br />
<br />
<sup>*</sup> {la jalge} is used for an bound variable argument intended as a return value, but that's pure convention. In Ramcinfo's approach, any bound variable of selbri could be used as argument or return value as needed.<br />
<br />
<sup>†</sup> Experimental<br />
<br />
<sup>‡</sup> Proposed or re-purposed specially for use in these systems<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117624User:Ramcinfo/fancu staile2015-09-21T00:12:01Z<p>Ramcinfo: /* Comparison with Ross Ogilvie's system */</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {ka}:<br />
lo goi la xunre xiky ge'u ka [ce'u] klesi [ce'u] fi lo ka xunre kei kei<br />
// var redFilter = function (sample) { return filter(sample, red); }; <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== Comparison with Ross Ogilvie's system ==<br />
Ross Ogilvie presents a proposal for reformation of mex<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref> with some very similar ideas. Here's comparation of his notation with one used here:<br />
<br />
<br />
{| class="wikitable"<br />
|+ fancu staile/fancu bridi mekso comparison<br />
! operation !! Ramcinfo !! Ross Ogilvie<br />
|-<br />
| return value || no special notation<sup>*</sup>, ce'u, ke'a || ce'au<sup>‡</sup><br />
|-<br />
| variable binding || ce'ai<sup>†</sup> || zo'ai<sup>‡</sup> ({ce'ai} is also considered)<br />
|-<br />
| convert function bridi (definition) to sumti (first-class function value) || ka || xau<sup>‡</sup> ({ni}, {du'u} and {su'u} are also considered)<br />
|-<br />
| convert function bridi to sumti (result of function application) || lo kai'u<sup>†</sup> (ce'u) / lo'oi<sup>†</sup> (ke'a) || also {xau}<br />
|-<br />
| convert function selbri to sumti (using functions as arguments) || me'ei<sup>†</sup> || ni'e<br />
|-<br />
| convert function sumti to selbri || me'au<sup>†</sup> || me<br />
|-<br />
| partial application || kai'u<sup>†</sup> || be'ei<sup>‡</sup><br />
|-<br />
| function composition || la finti<sup>‡</sup> || fancyjo'e<sup>‡</sup><br />
|-<br />
| curry || la karis.<sup>‡</sup> || na'u<sup>‡</sup><br />
|-<br />
| uncurry || - || nu'a<sup>‡</sup><br />
|-<br />
| list constructor || la zbasu<sup>‡</sup> || ce'o<br />
|-<br />
| map || - || porkanji<sup>‡</sup><br />
|-<br />
| fold || - || porjmina<sup>‡</sup><br />
|-<br />
| filter || klesi || -<br />
|}<br />
<br />
<sup>*</sup> {la jalge} is used for an bound variable argument intended as a return value, but that's pure convention. In Ramcinfo's approach, any bound variable of selbri could be used as argument or return value as needed.<br />
<sup>†</sup> Experimental<br />
<sup>‡</sup> Proposed or re-purposed specially for use in these systems<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117623User:Ramcinfo/fancu staile2015-09-21T00:09:36Z<p>Ramcinfo: /* Comparison with Ross Ogilvie's system */</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {ka}:<br />
lo goi la xunre xiky ge'u ka [ce'u] klesi [ce'u] fi lo ka xunre kei kei<br />
// var redFilter = function (sample) { return filter(sample, red); }; <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== Comparison with Ross Ogilvie's system ==<br />
Ross Ogilvie presents a proposal for reformation of mex<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref> with some very similar ideas. Here's comparation of his notation with one used here:<br />
<br />
<br />
{| class="wikitable"<br />
|+ fancu staile/fancu bridi mekso comparison<br />
! operation !! Ramcinfo !! Ross Ogilvie<br />
|-<br />
| return value || no special notation*, ce'u, ke'a || ce'au‡<br />
|-<br />
| variable binding || ce'ai† || zo'ai‡ ({ce'ai} is also considered)<br />
|-<br />
| convert function bridi (definition) to sumti (first-class function value) || ka || xau‡ ({ni}, {du'u} and {su'u} are also considered)<br />
|-<br />
| convert function bridi to sumti (result of function application) || lo kai'u† (ce'u) / lo'oi† (ke'a) || also {xau}<br />
|-<br />
| convert function selbri to sumti (using functions as arguments) || me'ei† || ni'e<br />
|-<br />
| convert function sumti to selbri || me'au† || me<br />
|-<br />
| partial application || kai'u† || be'ei‡<br />
|-<br />
| function composition || la finti‡ || fancyjo'e‡<br />
|-<br />
| curry || la karis.‡ || na'u‡<br />
|-<br />
| uncurry || - || nu'a‡<br />
|-<br />
| list constructor || la zbasu‡ || ce'o<br />
|-<br />
| map || - || porkanji‡<br />
|-<br />
| fold || - || porjmina‡<br />
|-<br />
| filter || klesi || -<br />
|}<br />
<br />
*{la jalge} is used for an bound variable argument intended as a return value, but that's pure convention. In Ramcinfo's approach, any bound variable of selbri could be used as argument or return value as needed.<br />
† Experimental<br />
‡ Proposed or re-purposed specially for use in these systems<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117622User:Ramcinfo/fancu staile2015-09-21T00:04:11Z<p>Ramcinfo: /* Comparison with Ross Ogilvie's system */</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {ka}:<br />
lo goi la xunre xiky ge'u ka [ce'u] klesi [ce'u] fi lo ka xunre kei kei<br />
// var redFilter = function (sample) { return filter(sample, red); }; <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== Comparison with Ross Ogilvie's system ==<br />
Ross Ogilvie presents a proposal for reformation of mex<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref> with some very similar ideas. Here's comparation of his notation with one used here:<br />
<br />
<br />
{| class="wikitable"<br />
|+ fancu staile/fancu bridi mekso comparison<br />
! operation !! Ramcinfo !! Ross Ogilvie<br />
|-<br />
| return value || no special notation*, ce'u, ke'a || ce'au<br />
|-<br />
| variable binding || ce'ai || zo'ai ({ce'ai} is also considered)<br />
|-<br />
| convert function bridi (definition) to sumti (first-class function value) || ka || xau ({ni}, {du'u} and {su'u} are also considered)<br />
|-<br />
| convert function bridi to sumti (result of function application) || lo kai'u (ce'u) / lo'oi (ke'a) || also {xau}<br />
|-<br />
| convert function selbri to sumti (using functions as arguments) || me'ei || ni'e<br />
|-<br />
| convert function sumti to selbri || me'au || me<br />
|-<br />
| partial application || kai'u || be'ei<br />
|-<br />
| function composition || la finti || fancyjo'e<br />
|-<br />
| curry || la karis. || na'u<br />
|-<br />
| uncurry || - || nu'a<br />
|-<br />
| list constructor || la zbasu || ce'o<br />
|-<br />
| map || - || porkanji<br />
|-<br />
| fold || - || porjmina<br />
|-<br />
| filter || klesi || -<br />
|}<br />
<br />
*{la jalge} is used for an bound variable argument intended as a return value, but that's pure convention. In Ramcinfo's approach, any bound variable of selbri could be used as argument or return value as needed.<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117621User:Ramcinfo/fancu staile2015-09-21T00:00:56Z<p>Ramcinfo: /* Comparison with Ross Ogilvie's system */</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {ka}:<br />
lo goi la xunre xiky ge'u ka [ce'u] klesi [ce'u] fi lo ka xunre kei kei<br />
// var redFilter = function (sample) { return filter(sample, red); }; <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== Comparison with Ross Ogilvie's system ==<br />
Ross Ogilvie presents a proposal for reformation of mex<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref> with some very similar ideas. Here's comparation of his notation with one used here:<br />
<br />
<br />
{| class="wikitable"<br />
|+ fancu staile/fancu bridi mekso comparison<br />
! operation !! Ramcinfo !! Ross Ogilvie<br />
|-<br />
| return value || no special notation*, ce'u, ke'a || ce'au<br />
|-<br />
| variable binding || ce'ai || zo'ai ({ce'ai} is also considered)<br />
|-<br />
| convert function bridi (definition) to sumti (first-class function value) || ka || xau ({ni}, {du'u} and {su'u} are also considered)<br />
|-<br />
| convert function bridi to sumti (result of function application) || lo kai'u (ce'u) / lo'oi (ke'a) || also {xau}<br />
|-<br />
| convert function selbri to sumti (using functions as arguments) || me'ei || ni'e<br />
|-<br />
| convert function sumti to selbri || me'au || me<br />
|-<br />
| partial application || kai'u || be'ei<br />
|-<br />
| function composition || la finti || fancyjo'e<br />
|-<br />
| curry || la karis. || na'u<br />
|-<br />
| uncurry || - || nu'a<br />
|-<br />
| list constructor || la zbasu || ce'o<br />
|-<br />
| map || - || porkanji<br />
|-<br />
| fold || - || porjmina<br />
|-<br />
| filter || klesi || -<br />
|}<br />
<br />
*{la jalge} is used for an bound variable argument intended as a return value, but that's pure convention. In Ramcinfo's approach, any bound variables of selbri could be used as arguments and return value(s) as needed.<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117620User:Ramcinfo/fancu staile2015-09-20T23:59:31Z<p>Ramcinfo: /* Comparison with Ross Ogilvie's system */</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {ka}:<br />
lo goi la xunre xiky ge'u ka [ce'u] klesi [ce'u] fi lo ka xunre kei kei<br />
// var redFilter = function (sample) { return filter(sample, red); }; <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== Comparison with Ross Ogilvie's system ==<br />
Ross Ogilvie presents a proposal for reformation of mex<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref> with some very similar ideas. Here's comparation of his notation with one used here:<br />
<br />
<br />
{| class="wikitable"<br />
|+ fancu staile/fancu bridi mekso comparison<br />
! operation !! Ramcinfo !! Ross Ogilvie<br />
|-<br />
| return value || no special notation*, ce'u, ke'a || ce'au<br />
|-<br />
| variable binding || ce'ai || zo'ai ({ce'ai} is also considered)<br />
|-<br />
| convert function bridi (definition) to sumti (first-class function value) || ka || xau ({ni}, {du'u} and {su'u} are also considered)<br />
|-<br />
| convert function bridi to sumti (result) || lo kai'u (ce'u) / lo'oi (ke'a) || also {xau}<br />
|-<br />
| convert function selbri to sumti (using functions as arguments) || me'ei || ni'e<br />
|-<br />
| convert function sumti to selbri || me'au || me<br />
|-<br />
| partial application || kai'u || be'ei<br />
|-<br />
| function composition || la finti || fancyjo'e<br />
|-<br />
| curry || la karis. || na'u<br />
|-<br />
| uncurry || - || nu'a<br />
|-<br />
| list constructor || la zbasu || ce'o<br />
|-<br />
| map || - || porkanji<br />
|-<br />
| fold || - || porjmina<br />
|-<br />
| filter || klesi || -<br />
|}<br />
<br />
*{la jalge} is used for an bound variable argument intended as a return value, but that's pure convention. In Ramcinfo's approach, any bound variables of selbri could be used as arguments and return value(s) as needed.<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117619User:Ramcinfo/fancu staile2015-09-20T23:48:13Z<p>Ramcinfo: /* Comparison with Ross Ogilvie's system */</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {ka}:<br />
lo goi la xunre xiky ge'u ka [ce'u] klesi [ce'u] fi lo ka xunre kei kei<br />
// var redFilter = function (sample) { return filter(sample, red); }; <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== Comparison with Ross Ogilvie's system ==<br />
Ross Ogilvie presents a proposal for reformation of mex<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref> with some very similar ideas. Here's comparation of his notation with one used here:<br />
<br />
<br />
{| class="wikitable"<br />
|+ fancu staile comparison<br />
! operation !! Ramcinfo !! Ross Ogilvie<br />
|-<br />
| return value || no special notation*, ce'u, ke'a || ce'au<br />
|-<br />
| variable binding || ce'ai || zo'ai ({ce'ai} is also considered)<br />
|-<br />
| convert function bridi (definition) to sumti (first-class function value) || ka || xau ({ni}, {du'u} and {su'u} are also considered)<br />
|-<br />
| convert function bridi to sumti (result) || lo kai'u (ce'u) / lo'oi (ke'a) || also {xau}<br />
|-<br />
| convert function selbri to sumti (using functions as arguments) || me'ei || ni'e<br />
|-<br />
| partial application || kai'u || be'ei<br />
|-<br />
| function composition || la finti || fancyjo'e<br />
|-<br />
| curry || la karis. || na'u<br />
|-<br />
| uncurry || - || nu'a<br />
|-<br />
| list constructor || la zbasu || ce'o<br />
|-<br />
| map || - || porkanji<br />
|-<br />
| fold || - || porjmina<br />
|-<br />
| filter || klesi || -<br />
|}<br />
<br />
*{la jalge} is used for an bound variable argument intended as a return value, but that's pure convention.<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117618User:Ramcinfo/fancu staile2015-09-20T23:19:51Z<p>Ramcinfo: Comparison with Ross Ogilvie's system</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {ka}:<br />
lo goi la xunre xiky ge'u ka [ce'u] klesi [ce'u] fi lo ka xunre kei kei<br />
// var redFilter = function (sample) { return filter(sample, red); }; <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== Comparison with Ross Ogilvie's system ==<br />
Ross Ogilvie presents a proposal for reformation of mex<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref> with some very similar ideas. Here's comparation of his notation with one used here:<br />
<br />
<br />
{| class="wikitable"<br />
|+ fancu staile comparison<br />
! operation !! Ramcinfo !! Ross Ogilvie<br />
|-<br />
| using functions as arguments || me'ei || ni'e<br />
|-<br />
| partial application || kai'u || be'ei<br />
|-<br />
| function composition || la finti || fancyjo'e<br />
|-<br />
| curry || la karis. || na'u<br />
|-<br />
| uncurry || - || nu'a<br />
|-<br />
| list constructor || la zbasu || ce'o<br />
|-<br />
| map || - || porkanji<br />
|-<br />
| fold || - || porjmina<br />
|-<br />
| filter || klesi || -<br />
|}<br />
<br />
<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/lojbo_staile_liste&diff=117617User:Ramcinfo/lojbo staile liste2015-09-20T22:02:27Z<p>Ramcinfo: </p>
<hr />
<div>Principal purpose of this list is to explore ways to use Lojban different from Indo-European natlang ways.<br />
==Lojban-specific==<br />
* cmavo-only style<ref>[http://www.lojban.org/tiki/tiki-view_forum_thread.php?forumId=5&comments_parentId=7703&topics_offset=324&topics_sort_mode=lastPost_desc Lojban with only cmavo: an Oulipian strategy]</ref><br />
==Inspired by real language features==<br />
* {{vlapoi|sumcau|staile}}, inspired by nounless languages like that of Salishan and Wakashan families<ref>[https://www.dropbox.com/s/kvj63dtew6hs3z3/ENG%20Davidson%2CM.%20-%20Studies%20in%20southern%20Wakashan%20%28Nootkan%29%20grammar.pdf?dl=0 A grammar of Nootkah]</ref><ref>[https://en.wikipedia.org/wiki/Lojban#Syntax_and_semantics Example of Lojban imitating Nuu-chah-nulth] (near the end of the section). Note that it is also agglutinative.</ref>.<br />
==Inspired by other constructed languages==<br />
* Verbless style inspired by Kēlen<ref>[http://www.terjemar.net/grammar.php Kēlen Grammar]</ref><br />
* toki pona style, with e.g. anaphora instead of nested constructs ({mi pinxe lo tcati .i mi masno lonu go'i}). Vocabulary might or might not be restricted.<br />
==Inspired by fictional languages==<br />
* Tlön styles, from Borges’ short story. Most Tlön languages lack nouns, so sumti are either avoided or thought of as combinations of properties and/or relations. {{jvs|za'a}} and {{jvs|si'au}} evidentials are common.<br />
:* snanu .utloine staile: in Southern Tlön style, meaning is constructed from verbs and adverbs. Example:<br />
{{mu|mo'i ga'u ku ti'a lo zu'o ru'i flecu cu co'a mluni}}<br />
:* berti .utloine staile: in Northern Tlön style, objects are referred to by combination of adjectives (qualities). Possible lojbanic ways to do so: {{jvs|ka}} and {{jvs|za'i}} abstractions, modals making main level bridi into such abstractions (especially {{vlapoi|kai|ku}} and {{vlapoi|ri'i|ku}}, also {{vlapoi|ci'o|ku}} and {{vlapoi|mu'u|ku}}), {{vlapoi|ca'o|nai}} and {{vlapoi|co'i|nai}} event contours, {{jvs|ru'i}} and {{jvs|ze'e}} interval properties. Example:<br />
{{mu|kai vacri je gusni ne'i lo kai'u narju je kandi je tsani}}<br />
<br />
<br />
{{notci|Note: I am tempted to replace {lo zu'o} and {lo kai'u} with something other in these examples, to completely avoid references to (non-abstract) objects.}}<br />
* melaxoxengron staile, inspired by “language of dreams” in Max Frei novels. Similar to (especially Northern) Tlön style; default evidential is {{jvs|si'au}}, {{jvs|se'o}} may also be used.<br />
==Inspired by programming languages==<br />
* {{vlapoi|minde|sampla|staile}}, corresponding to imperative programming paradigm. Instead of claims, predicates are understood as commands. Some attempts are done here: [[Writing algorithms in Lojban]].<br />
* {{vlapoi|fancu|sampla|staile}}, corresponding to functional -"- -"- . Selbri understood as functions. See [[User:Ramcinfo/fancu_staile|the draft]].<br />
* {{vlapoi|logji|sampla|staile}}, corresponding to logical -"- -"- . Early draft is [[User:Ramcinfo/logji_staile|here]]. See also la jimpe<ref>http://web.mit.edu/~rspeer/Public/jimpe.pdf</ref>.<br />
* {{vlapoi|tinsa|tectaipe|staile}}, corresponding to strict typing.<br />
==Miscellaneous==<br />
* Stack staile, based on proglangs like Forth and PostScript and conlangs like [[Fith]] and Nalnuàntir<ref>http://conlang.wikia.com/wiki/Nalnu%C3%A0ntir</ref><br />
* Improvements of mekso, e.g. fancu bridi mekso proposal<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref><br />
=Credits=<br />
Many ideas were proposed by [[la gleki]].<br />
=References=<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/lojbo_staile_liste&diff=117616User:Ramcinfo/lojbo staile liste2015-09-20T22:01:40Z<p>Ramcinfo: </p>
<hr />
<div>Principal purpose of this list is to explore ways to use Lojban different from Indo-European natlang ways.<br />
==Lojban-specific==<br />
* cmavo-only style<ref>[http://www.lojban.org/tiki/tiki-view_forum_thread.php?forumId=5&comments_parentId=7703&topics_offset=324&topics_sort_mode=lastPost_desc Lojban with only cmavo: an Oulipian strategy]</ref><br />
==Inspired by real language features==<br />
* {{vlapoi|sumcau|staile}}, inspired by nounless languages like that of Salishan and Wakashan families<ref>[https://www.dropbox.com/s/kvj63dtew6hs3z3/ENG%20Davidson%2CM.%20-%20Studies%20in%20southern%20Wakashan%20%28Nootkan%29%20grammar.pdf?dl=0 A grammar of Nootkah]</ref><ref>[https://en.wikipedia.org/wiki/Lojban#Syntax_and_semantics Example of Lojban imitating Nuu-chah-nulth] (near the end of the section). Note that it is also agglutinative.</ref>.<br />
==Inspired by other constructed languages==<br />
* Verbless style inspired by Kēlen<ref>[http://www.terjemar.net/grammar.php Kēlen Grammar]</ref><br />
* toki pona style, with e.g. anaphora instead of nested constructs ({mi pinxe lo tcati .i mi masno lonu go'i}). Vocabulary might or might not be restricted.<br />
==Inspired by fictional languages==<br />
* Tlön styles, from Borges’ short story. Most Tlön languages lack nouns, so sumti are either avoided or thought of as combinations of properties and/or relations. {{jvs|za'a}} and {{jvs|si'au}} evidentials are common.<br />
:* snanu .utloine staile: in Southern Tlön style, meaning is constructed from verbs and adverbs. Example:<br />
{{mu|mo'i ga'u ku ti'a lo zu'o ru'i flecu cu co'a mluni}}<br />
:* berti .utloine staile: in Northern Tlön style, objects are referred to by combination of adjectives (qualities). Possible lojbanic ways to do so: {{jvs|ka}} and {{jvs|za'i}} abstractions, modals making main level bridi into such abstractions (especially {{vlapoi|kai|ku}} and {{vlapoi|ri'i|ku}}, also {{vlapoi|ci'o|ku}} and {{vlapoi|mu'u|ku}}), {{vlapoi|ca'o|nai}} and {{vlapoi|co'i|nai}} event contours, {{jvs|ru'i}} and {{jvs|ze'e}} interval properties. Example:<br />
{{mu|kai vacri je gusni ne'i lo kai'u narju je kandi je tsani}}<br />
<br />
<br />
{{notci|Note: I am tempted to replace {lo zu'o} and {lo kai'u} with something other in these examples, to completely avoid references to (non-abstract) objects.}}<br />
* melaxoxengron staile, inspired by “language of dreams” in Max Frei novels. Similar to (especially Northern) Tlön style; default evidential is {{jvs|si'au}}, {{jvs|se'o}} may also be used.<br />
==Inspired by programming languages==<br />
* {{vlapoi|minde|sampla|staile}}, corresponding to imperative programming paradigm. Instead of claims, predicates are understood as commands. Some attempts are done here: [[Writing algorithms in Lojban]].<br />
* {{vlapoi|fancu|sampla|staile}}, corresponding to functional -"- -"- . Selbri understood as functions. See [[User:Ramcinfo/fancu_staile|the draft]]. Ross Oglive also explores this approach<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref>.<br />
* {{vlapoi|logji|sampla|staile}}, corresponding to logical -"- -"- . Early draft is [[User:Ramcinfo/logji_staile|here]]. See also la jimpe<ref>http://web.mit.edu/~rspeer/Public/jimpe.pdf</ref>.<br />
* {{vlapoi|tinsa|tectaipe|staile}}, corresponding to strict typing.<br />
==Miscellaneous==<br />
* Stack staile, based on proglangs like Forth and PostScript and conlangs like [[Fith]] and Nalnuàntir<ref>http://conlang.wikia.com/wiki/Nalnu%C3%A0ntir</ref><br />
* Improvements of mekso, e.g. fancu bridi mekso proposal<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref><br />
=Credits=<br />
Many ideas were proposed by [[la gleki]].<br />
=References=<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117605User:Ramcinfo/fancu staile2015-09-19T23:10:17Z<p>Ramcinfo: /* curry */</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {ka}:<br />
lo goi la xunre xiky ge'u ka [ce'u] klesi [ce'u] fi lo ka xunre kei kei<br />
// var redFilter = function (sample) { return filter(sample, red); }; <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117604User:Ramcinfo/fancu staile2015-09-19T23:09:15Z<p>Ramcinfo: /* curry */</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {ka}:<br />
lo goi la xunre xiky ge'u ka [ce'u] klesi [ce'u] fi lo ka xunre kei<br />
// var redFilter = function (sample) { return filter(sample, red); }; <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117603User:Ramcinfo/fancu staile2015-09-19T19:42:02Z<p>Ramcinfo: /* Notes */</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {kai'u}:<br />
lo goi la xunre xiky ge'u kai'u [ce'u] klesi [ce'u] fi lo ka xunre kei // var redFilter = filter({definingProperty: red}); <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u a'y ce'o by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117602User:Ramcinfo/fancu staile2015-09-19T19:23:37Z<p>Ramcinfo: /* curry */ correct (sorta) js in translation</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {kai'u}:<br />
lo goi la xunre xiky ge'u kai'u [ce'u] klesi [ce'u] fi lo ka xunre kei // var redFilter = filter({definingProperty: red}); <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117601User:Ramcinfo/fancu staile2015-09-19T19:20:59Z<p>Ramcinfo: /* curry */ typo</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jalge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {kai'u}:<br />
lo goi la xunre xiky ge'u kai'u [ce'u] klesi [ce'u] fi lo ka xunre kei // var redFilter = filter(definingProperty=red); <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117600User:Ramcinfo/fancu staile2015-09-19T19:15:48Z<p>Ramcinfo: practical example of currying</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Practical (hehe...) example:<br />
<br />
la klesi xiky cu me'au la karis. me'u me'ei setese klesi // var curriedFilter = curry(filter);<br />
.i la xunre xiky cu me'au la klesi xiky me'u lo ka xunre // var redFilter = curriedFilter(red);<br />
.i la jakge xipu cu me'au la xunre xiky me'u lo seltadni xipu // var result1 = redFilter(sample1);<br />
.i la jakge xipu cu me'au la xunre xiky me'u lo seltadni xire // var result2 = redFilter(sample2);<br />
<br />
In effect, we reinvented {kai'u}:<br />
lo goi la xunre xiky ge'u kai'u [ce'u] klesi [ce'u] fi lo ka xunre kei // var redFilter = filter(definingProperty=red); <br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117597User:Ramcinfo/fancu staile2015-09-18T09:17:56Z<p>Ramcinfo: /* curry */</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo ''goi'' <u>la karis.</u> ''ge'u'' ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo ''goi'' <u>la karis.xipa</u> ''ge'u'' ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo ''goi'' <u>la terbri xipa</u> ''ge'u'' poi'i<br />
ke'a ''me'au'' <u>la zbasu</u> ''me'u'' <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu ''me'au'' lo ''me'au'' <u>la cunxa</u> ''me'u''<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu ''me'au'' <u>la karis.xipa</u> ''me'u'' <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117596User:Ramcinfo/fancu staile2015-09-18T09:14:55Z<p>Ramcinfo: Fixing typo</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'ai<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'ai<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'ai<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo goi <u>la karis.</u> ge'u ka<br />
<u>la jalge</u> <u>la fancu</u> ce'ai<br />
lo goi <u>la karis.xipa</u> ge'u ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'ai<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'ai<br />
lo goi <u>la terbri xipa</u> ge'u poi'i<br />
ke'a me'au <u>la zbasu</u> me'u <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu me'au lo me'au <u>la cunxa</u> me'u<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu me'au <u>la karis.xipa</u> me'u <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/fancu_staile&diff=117595User:Ramcinfo/fancu staile2015-09-18T09:06:24Z<p>Ramcinfo: syntax highlighting :)</p>
<hr />
<div>This is an attempt to use lojban as a functional programming language. It was in part inspired by [[Missing_predicates#List|Tsani’s recursive predicate]] and, while developed mostly independently, many things are done the same.<br />
<br />
Let us think about selbri as function taking its terbri as arguments and returning the predication, or bridi. This predication can be then claimed in context, returning truth-value of resulting bridi in that context.<br />
<br />
function tavla(speaker, listener, subject, language) {...} // returns predication<br />
function claim(predication, context) {...} // returns boolean<br />
claim(tavla("me", "you", "lojban", "lojban"), context);<br />
<br />
To build functions returning other things, we can use {lo}. Let us not go into intricacies of descriptors and pretend what {lo selbri} returns simply ''some'' value s1 such that claim(selbri(s1, s2...sx), context) will be true for ''some'' values of s2...sx and claimed with ''some'' context. Arguments other than context could be restricted with {be...bei...be'o}. So {lo selbri be sumti2 bei sumti3 be'o} is x1 = selbri1(sumti2, sumti3).<br />
<br />
{loka}- and {me'ei}-abstractions, then, are predication-returning functions as first-class values. {me'au} with these abstractions is function application; {kai'u} is immediate function application.<br />
<br />
== apply ==<br />
We are now ready to construct functions taking functions as arguments and/or returning other functions. Let's start with ''apply'' (for unary function):<br />
<br />
lo goi la pliri'a ge'u ka la jalge la fancu la sumti ce'ai<br />
la jalge cu me'au la fancu la sumti kei<br />
<br />
function apply(fun, arg) {<br />
return fun(arg); } <br />
<br />
Now we can use it as such:<br />
<br />
lo me'au la pliri'a me'u be me'ei tavla bei mi be'o<br />
<br />
It could be rewritten in CLL Lojban, but would be (even) less readable:<br />
cylylypapi'epa jo'au<br />
lo ka bridi ce'u ce'u ce'o ce'u kei goi ko'a<br />
zo'u co'e zo'e poi bridi be ko'a bei lo ka ce'u tavla ce'u ku ce'o ke'a ce'o mi<br />
<br />
== compose ==<br />
<br />
Function composition, ''compose'' (for unary functions, still):<br />
lo goi la finti ge'u ka la jalge la fancu xipa la fancu xire ce'ai<br />
la jalge cu ka la jalge xipa la sumti ce'ai<br />
la jalge xipa cu me'au la fancu xipa lo me'au la fancu xire ku be la sumti kei kei<br />
<br />
function compose(fun, fuun) {<br />
return function (arg) {<br />
return fun(fuun(arg)); }}<br />
<br />
== Recursion ==<br />
<br />
Infinite recursion (do not try it at home):<br />
<br />
lo goi la cimnrekursi ge'u ka me'au la cimnrekursi kei <br />
<br />
function infRec() {<br />
infRec();<br />
}<br />
<br />
I am not sure of the last one. Maybe {goi} works only forward in scope. {me'au lo ka nei} (or simply {nei}) will do almost the same, I guess.<br />
<br />
== if ==<br />
<br />
Confitional (taken from Tsani’s recursive predicate definition, replacing {ckaji} with {du}):<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
ge ganai me'au la krinu gi la jalge cu du by<br />
gi ga me'au la krinu gi la jalge cu du cy kei<br />
<br />
(What if replace {du} with {me'au}?)<br />
Maybe also la gleki's {ifle} will work:<br />
<br />
lo goi la cuxna ge'u ka la jalge la krinu by boi cy ce'ai<br />
la krinu cu ifle<br />
lo du'u la jalge cu du by kei<br />
lo du'u la jalge cu du cy kei kei<br />
<br />
== Recursion (again) ==<br />
<br />
Now we are ready to build a simple recursion. {krasi} and {fanmo} are used to get first and last elements of sequence, respectively; I am not very sure if this is appropriate. Now if the style is to be developed in the direction of LISP, then functions working on sequences, like ''head'', ''tail'' and ''cons'' are to be defined.<br />
<br />
{je'abo goi} is a hack even dirtier than it is usual for these matters; it is used to both a) group the sequence as one sumti to attach relative clause to it and b) to move that clause to the front.<br />
<br />
lo goi la kancu ge'u ka la jalge la porsi la cabna ce'ai<br />
la jalge cu me'au la cuxna lo du'u la cabna cu fanmo la porsi kei li pa<br />
lo sumji be li pa lo me'au la kancu ku<br />
be la porsi bei lo bavla'i be la cabna bei la porsi kei<br />
je'abo goi la mupli ge'u by ce'o cy ce'o dy zo'u<br />
li ci cu me'au la kancu la mupli lo krasi be la mupli<br />
<br />
// approximately<br />
function len(list, item) {<br />
return (list.indexOf(item) === list.length - 1) ? 1 :<br />
1 + len(list, list[list.indexOf(item)] + 1); }<br />
var sample = ["b", "c", "d"];<br />
assert(3 === len(sample, sample[0]));<br />
<br />
== curry ==<br />
For now, let us pretend that we already have function for ''cons'', being {la zbasu} (x1 is sequence with head x2 and tail sequence x3. We'll also use {tersu'imei} for getting function (selbri) arity (we could use {lo se pormei be lo se zilbri be lo ka broda}, or above defined {la kancu} instead of {se pormei}).<br />
<br />
lo goi la karis. ge'u ka<br />
la jalge la fancu ce'oi<br />
lo goi la karis.xipa ge'u ka<br />
la jalge xipa la fancu xipa la terbri ce'oi<br />
la jalge xipa cu ka<br />
la jalge xire la sumti ce'oi<br />
lo goi la terbri xipa ge'u poi'i<br />
ke'a me'au la zbasu me'u la sumti la terbri kei zo'u<br />
la jalge xire cu me'au la cuxna me'u<br />
lo du'u lo se tersu'imei be la fancu xipa cu dubdu'i<br />
lo se pormei be la terbri xipa kei<br />
lo poi'i ke'a bridi la fancu xipa la terbri xipa kei<br />
lo poi'i ke'a me'au la karis.xipa me'u la fancu xipa la terbri xipa kei kei kei zo'u<br />
la jalge cu me'au la karis.xipa me'u la fancu lo kutpoi kei<br />
<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
if (fun.length == args1.length) {<br />
return fun(args1)<br />
} else {<br />
return curry1(fun, args1);<br />
}<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
Usage:<br />
la fanxu xinu cu me'au la karis. me'u la fancu<br />
.i la fanxu xipu cu me'au la fancu xinu me'u li pu<br />
.i la fanxu xire cu me'au la fancu xipu me'u li re<br />
.i la jalge cu me'au la fanxu xire me'u li ci<br />
<br />
var curriedFun = curry(fun);<br />
var curriedFun1 = curriedFun(1);<br />
var curriedFun2 = curriedFun(2);<br />
var result = curriedFun(3);<br />
<br />
Conditional could be rewritten shorter, but more cryptically (as this style is new):<br />
lo goi <u>la karis.</u> ge'u ka<br />
<u>la jalge</u> <u>la fancu</u> ce'oi<br />
lo goi <u>la karis.xipa</u> ge'u ka<br />
<u>la jalge xipa</u> <u>la fancu xipa</u> <u>la terbri</u> ce'oi<br />
<u>la jalge xipa</u> cu ka<br />
<u>la jalge xire</u> <u>la sumti</u> ce'oi<br />
lo goi <u>la terbri xipa</u> ge'u poi'i<br />
ke'a me'au <u>la zbasu</u> me'u <u>la sumti</u> <u>la terbri</u> kei zo'u<br />
<u>la jalge xire</u> cu me'au lo me'au <u>la cunxa</u> me'u<br />
lo du'u lo se tersu'imei be <u>la fancu xipa</u> cu dubdu'i<br />
lo se pormei be <u>la terbri xipa</u> kei<br />
me'ei bridi <u>la karis.xipa</u> me'u <u>la fancu xipa</u> <u>la terbri xipa</u> kei kei zo'u<br />
<u>la jalge</u> cu me'au <u>la karis.xipa</u> me'u <u>la fancu</u> lo kutpoi kei<br />
<br />
//function apply(fun, args) {return fun.apply(this, args); }<br />
function curry(fun) {<br />
function curry1(fun, args) {<br />
return function (arg) {<br />
var args1 = args;<br />
args1.unshift(arg);<br />
return ((fun.length == args1.length) ? apply : curry1)(fun, args1);<br />
}<br />
}<br />
return curry1(fun, []);<br />
}<br />
<br />
== Notes ==<br />
For conversion between predicate taking sequence as argument and n-ary predicate, {brije'u} (alias {zilbri}) is most natural way:<br />
<br />
a'y konkatena byboi cyboi dyboi ... ≡ me'ei konkatena cu brije'u by ce'o cy ce'o dy ...<br />
<br />
Various ways to call a function:<br />
<br />
'''lo''' me'au la ''fancu'' me'u '''be''' ''la sumti'' '''bei''' ''la sumti'' '''be'o'''<br />
<br />
'''lo poi'i ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo kai'u ce'u''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''kei'''<br />
<br />
'''lo'oi ke'a''' me'au la ''fancu'' me'u ''la sumti'' ''la sumti'' '''ku'au'''<br />
<br />
== buboi ==<br />
In the first version of this draft, {cizra} consctruction {<u>NAME buboi</u>} was used for variable names. It was a hack, but I knew no better way to assign more-or-less meaningful names to assignable variables. Without {buboi}, I'd be up to my neck in {ko'a}s. Luckily, la menli proposed assigning values with {goi} to cmene. Though {goi} behavior is not fully standardized <ref>http://mw.lojban.org/papri/Lojban_application_issues</ref>, I consisently place name to be assigned after it, and value being assigned before.<br />
<br />
[[Image:aulbuboi.jpg|thumb|100px| ]]<br />
== References ==<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=experimental_rafsi&diff=115364experimental rafsi2015-06-14T17:00:01Z<p>Ramcinfo: Minor typo fix</p>
<hr />
<div>aka "[[rafsi]] not in the official lists" (some are mentioned in [[CLL]], though).<br />
*{{jvs|jai}} rafsi: '''jax''', '''jaz'''<br />
*{{jvs|nei}} rafsi: '''nej'''<br />
*{{jvs|zi'o}} rafsi: '''zil''' (in the gismu list, just not the rafsi list)<br />
*{{jvs|kibro}} rafsi: '''kib''' (experimental gismu)<br />
<br />
*[[rab.spir|rab.spir]]:<br />
*:I suggest these for hex digits:<br />
**{{jvs|dau}} rafsi: duv<br />
**{{jvs|fei}} rafsi: fel<br />
**{{jvs|gai}} rafsi: gam<br />
**{{jvs|jau}} rafsi: juz<br />
**[[xei]] rafsi: xem<br />
**{{jvs|vai}} rafsi: vav<br />
<br />
*[[Adam|Adam]]:<br />
*:{{jvs|rei}} rafsi: rex (for those who don't see the need for [[xei|xei]])<br />
** Or just say that xem is a rafsi for xei or rei, whichever you use.<br />
*** No other cmavo has a rafsi whose only similarity to it is the vowel.<br />
<br />
coi doi ro do mi'e .telselkik. .i .u'u mi co'a rafsypli<br />
.i du'e jbopre pu pante lo za'i lo rafsi cu na'e xamgu kei mi<br />
lo drata be lo nu sampu zbasu lo xamgu lo na'e selpli rafsi<br />
.i .ai .au co'a cikre .i ko xendo bi'a sidju .au<br />
<br />
* .i zo {{jvs|selja'e}} se rafsi ti'e ra'oi '''se'e''' (to mi mi'e .tel. na'e finti .i milxe laldo ca .i racli pe'i .i .ei sai lo nu na'e satci cu banzu frili bau la ma'a melbau toi)<br />
* .i zo {{jvs|mu'umgu}} se rafsi ca'e ra'oi '''mug''' (to mi sezysarxe li'a mu'umgu ra'oi '''mug''' lo nu mugyta'a kei lo jbopre toi)<br />
* .i ra'oi '''zmo''' zo'u: ''fabu'' pilno ''febu'' lo nu ''febu'' jai stika lo ka ''fabu'' lifri ma kau kei lo mutce .i fanva zo'oi ''high'' .e zo'oi ''intoxicated'' .e zo'oi ''entranced'' (to no da ca se rafsi .i ku'i cumki li'a fa lo nu finti lo jitfa krasi zi'evla toi)<br />
** pe'i .ei sai ro gu'e se valsi be fi zo'e gi smuni cu se brivla da .i se ki'u bo tu'e ca'e zo {{jvs|zmo'una}} se rafsi zo'oi. zmo. tu'u .i ko va'o lo nu na nelci cu jai stika<br />
* .i ra'oi '''bom''' .e ra'oi '''nom''' .i srana lo nu pilno lo rafsi pe lo jvocme lo nu zbasu lo lujvo .i ka'u ma'a cafne je zasni je xalbo finti lo simsa .i zo xorxesyjbo cu mupli .i la selpa'i ku noi banli cu pilno ti'e (to mi korpora zei sisku mupli facki toi) .i li'a tavla fi la .xorxes. noi ji'a banli .i na li'a tavla fi lo xelso mu'a .i ku'i malrarbausmi relsmununrafpli .i to'e jbosarxe pe'i .i ro ma'a djuno lo du'u na'e jbosarxe .i ma'a mu'i pilno fi lo se xalbo po'o .i ku'i xamgu sidbo pe'i .i pe'i xlali tadji po'o .i .ei satci .i mi mu'i finti ra'oi '''bom''' .e ra'oi '''nom''' .i to'u zo xorxesyjbo cu binxo zo xorxesnomjbo .i ra'oi '''bom''' cu se pilno fi lo nu cmene lidne ke zmadu ciksi .i mu'a lu zabna me la .xorxes. me'u lojbo li'u cu ve lujvo fo zo zanbomxorxesnomjbo .i ca'e ru'e .ia ru'e lu lo combomcmevla li'u mu'a cu panra lu lo co'e do'e la cmevla li'u .i .ia sai .o'a plixautce ciste .i .au pilno lo na'e purselpli rafsi lo banzu xamgu .i xamgu pe'i fa lo nu kargau pe'a lo cnino poi vlaca'u .i zmadu vrici pilno lo zasti rafsi .ui poi sormei .i mutce prali .i .a'o do tugni .i va'i .a'o do nelci lo cizbomselkiknomsi'o doi jbope'o mi'e la stela selckiku mu'o pante<br />
* .i ra'oi '''ne'a''' rafsi ca'e zo bebna .i zo bebna cu cafne se pilno fi lo valsi fanmo .i ku'i lo mapti poi rafsi cu selpli fi no da .i pu malne'a pe'i<br />
<br />
zai ze'ei coi jbope'o mi'e .telselkik.<br />
.i mi ca'o rafsyxaksygau<br />
.i ji'a lo drata cu co'a sidju<br />
.i ji'a mi jajgau lo laldo se finti ti poi .uitki<br />
.i .a'o ro do plitce<br />
<br />
* .i ra'oi '''-xro-''' rafsi zo xrotu<br />
* .i ra'oi '''-glo-''' rafsi zo glotu<br />
* .i ra'oi '''-xlo-''' rafsi zo xlotu<br />
* .i ra'oi '''-va'a-''' rafsi zo va'arga<br />
* .i ra'oi '''-zvi-''' rafsi zo zviki noi la ramcinfo ca'o finti (provisional definition: x1 participates in co-creative act x2 in context of system x3 inspired/allowed by its quality x4; x1 hacks x3 exploiting x4 (x2 being the hack))<br />
* .i la danmo rozgu cu gasnu lo nu ra'oi '''-jbo-''' co'u rafsi zo lojbo je cu co'a rafsi zo jbobo (to ku'i smudu'i toi)<br />
* .i la .niftyg. cu gasnu lo nu ra'oi '''-bob-''' ji'a cu srana lo si'o bobyjbobylobybobyjbojbobylojbo .i mi finti zo bo'objo noi jitfykrasi<br />
* .i ra'oi '''-vob-''' rafsi zo vo'a si'au (to zo vobmipri co'e toi)<br />
* .i li'a ra'oi '''-goi-''' je ra'oi '''-zoi-''' vaitce .i no drata simsa tordu je cu nu'o selpli .i pe'i no cmalu smuni cu mapti .i .e'u srana lo nu zbasu lo bramau poi canlu .i ra'oi '''-goi-''' cu ca'e co'e lo kulnu rafsi .i za'a so'i prenu cu xebni lo kulnu rafsi .i na'e jbosarxe .i to'e klunu'i .i na'e cumki fa lo nu ro remna kulnu cu co'e lo tordu rafsi .i ku'i nandu fa lo nu gasnu lo nu lo zasti poi kulnu rafsi cu co'u se pilno .i mi ca troci lo nu ba'e ''muvdu'' .i ra'oi '''-mer-''' pu rafsi zo merko .i ra'oi '''-mergoi-''' ca'e co'a rafsi zo merko .i zo merpre binxo zo mergoipre .i da'i sai! ba lo ba zu nu ra'oi '''-mer-''' poi lunbe cu co'u pilno fi tu'a zo merko kei cu co'a xamgu fa lo nu pilno ra'oi '''-mer-''' lo drata .i zmadu vajni fa lo za'i kakne lo nu finti lo klunu'i dunli clani rafsi be do'e lo vrici poi kulnu je poi jbovla tu'a ki fa lo po'o na'e gismu .i ra'oi '''-zoi-''' simsa ca'e je cu srana lo ku'i zifre canlu .i mu'a ra'oi '''-vanzoi-''' rafsi zo vanlamigu .i zo vanzoizga mu'a lujvo fo lu vanlamigu zgana li'u .i cizra .ie nai pei fa lo da'i nu lo fadni tordu cu rafsi zo vanlamigu .i mu'i finti lo sarxe barda poi cnino je poi rafsi canlu</div>Ramcinfohttps://mw.lojban.org/index.php?title=experimental_rafsi&diff=115363experimental rafsi2015-06-14T16:32:06Z<p>Ramcinfo: </p>
<hr />
<div>aka "[[rafsi]] not in the official lists" (some are mentioned in [[CLL]], though).<br />
*{{jvs|jai}} rafsi: '''jax''', '''jaz'''<br />
*{{jvs|nei}} rafsi: '''nej'''<br />
*{{jvs|zi'o}} rafsi: '''zil''' (in the gismu list, just not the rafsi list)<br />
*{{jvs|kibro}} rafsi: '''kib''' (experimental gismu)<br />
<br />
*[[rab.spir|rab.spir]]:<br />
*:I suggest these for hex digits:<br />
**{{jvs|dau}} rafsi: duv<br />
**{{jvs|fei}} rafsi: fel<br />
**{{jvs|gai}} rafsi: gam<br />
**{{jvs|jau}} rafsi: juz<br />
**[[xei]] rafsi: xem<br />
**{{jvs|vai}} rafsi: vav<br />
<br />
*[[Adam|Adam]]:<br />
*:{{jvs|rei}} rafsi: rex (for those who don't see the need for [[xei|xei]])<br />
** Or just say that xem is a rafsi for xei or rei, whichever you use.<br />
*** No other cmavo has a rafsi whose only similarity to it is the vowel.<br />
<br />
coi doi ro do mi'e .telselkik. .i .u'u mi co'a rafsypli<br />
.i du'e jbopre pu pante lo za'i lo rafsi cu na'e xamgu kei mi<br />
lo drata be lo nu sampu zbasu lo xamgu lo na'e selpli rafsi<br />
.i .ai .au co'a cikre .i ko xendo bi'a sidju .au<br />
<br />
* .i zo {{jvs|selja'e}} se rafsi ti'e ra'oi '''se'e''' (to mi mi'e .tel. na'e finti .i milxe laldo ca .i racli pe'i .i .ei sai lo nu na'e satci cu banzu frili bau la ma'a melbau toi)<br />
* .i zo {{jvs|mu'umgu}} se rafsi ca'e ra'oi '''mug''' (to mi sezysarxe li'a mu'umgu ra'oi '''mug''' lo nu mugyta'a kei lo jbopre toi)<br />
* .i ra'oi '''zmo''' zo'u: ''fabu'' pilno ''febu'' lo nu ''febu'' jai stika lo ka ''fabu'' lifri ma kau kei lo mutce .i fanva zo'oi ''high'' .e zo'oi ''intoxicated'' .e zo'oi ''entranced'' (to no da ca se rafsi .i ku'i cumki li'a fa lo nu finti lo jitfa krasi zi'evla toi)<br />
** pe'i .ei sai ro gu'e se valsi be fi zo'e gi smuni cu se brivla da .i se ki'u bo tu'e ca'e zo {{jvs|zmo'una}} se rafsi zo'oi. zmo. tu'u .i ko va'o lo nu na nelci cu jai stika<br />
* .i ra'oi '''bom''' .e ra'oi '''nom''' .i srana lo nu pilno lo rafsi pe lo jvocme lo nu zbasu lo lujvo .i ka'u ma'a cafne je zasni je xalbo finti lo simsa .i zo xorxesyjbo cu mupli .i la selpa'i ku noi banli cu pilno ti'e (to mi korpora zei sisku mupli facki toi) .i li'a tavla fi la .xorxes. noi ji'a banli .i na li'a tavla fi lo xelso mu'a .i ku'i malrarbausmi relsmununrafpli .i to'e jbosarxe pe'i .i ro ma'a djuno lo du'u na'e jbosarxe .i ma'a mu'i pilno fi lo se xalbo po'o .i ku'i xamgu sidbo pe'i .i pe'i xlali tadji po'o .i .ei satci .i mi mu'i finti ra'oi '''bom''' .e ra'oi '''nom''' .i to'u zo xorxesyjbo cu binxo zo xorxesnomjbo .i ra'oi '''bom''' cu se pilno fi lo nu cmene lidne ke zmadu ciksi .i mu'a lu zabna me la .xorxes. me'u lojbo li'u cu ve lujvo fo zo zanbomxorxesnomjbo .i ca'e ru'e .ia ru'e lu lo combomcmevla li'u mu'a cu panra lu lo co'e do'e la cmevla li'u .i .ia sai .o'a plixautce ciste .i .au pilno lo na'e purselpli rafsi lo banzu xamgu .i xamgu pe'i fa lo nu kargau pe'a lo cnino poi vlaca'u .i zmadu vrici pilno lo zasti rafsi .ui poi sormei .i mutce prali .i .a'o do tugni .i va'i .a'o do nelci lo cizbomselkiknomsi'o doi jbope'o mi'e la stela selckiku mu'o pante<br />
* .i ra'oi '''ne'a''' rafsi ca'e zo bebna .i zo bebna cu cafne se pilno fi lo valsi fanmo .i ku'i lo mapti poi rafsi cu selpli fi no da .i pu malne'a pe'i<br />
<br />
zai ze'ei coi jbope'o mi'e .telselkik.<br />
.i mi ca'o rafsyxaksygau<br />
.i ji'a lo drata cu co'a sidju<br />
.i ji'a mi jajgau lo laldo se finti ti poi .uitki<br />
.i .a'o ro do plitce<br />
<br />
* .i ra'oi '''-xro-''' rafsi zo xrotu<br />
* .i ra'oi '''-glo-''' rafsi zo glotu<br />
* .i ra'oi '''-xlo-''' rafsi zo xlotu<br />
* .i ra'oi '''-va'a-''' rafsi zo va'arga<br />
* .i ra'oi '''-zvi-''' rafsi zo zviki noi la ramcinfo ca'o finti (provisional definition: x1 participates in co-creative act x2 in context of system x3 inspired/allowed by it quality x4; x1 hacks x3 exploiting x4 (x2 being the hack))<br />
* .i la danmo rozgu cu gasnu lo nu ra'oi '''-jbo-''' co'u rafsi zo lojbo je cu co'a rafsi zo jbobo (to ku'i smudu'i toi)<br />
* .i la .niftyg. cu gasnu lo nu ra'oi '''-bob-''' ji'a cu srana lo si'o bobyjbobylobybobyjbojbobylojbo .i mi finti zo bo'objo noi jitfykrasi<br />
* .i ra'oi '''-vob-''' rafsi zo vo'a si'au (to zo vobmipri co'e toi)<br />
* .i li'a ra'oi '''-goi-''' je ra'oi '''-zoi-''' vaitce .i no drata simsa tordu je cu nu'o selpli .i pe'i no cmalu smuni cu mapti .i .e'u srana lo nu zbasu lo bramau poi canlu .i ra'oi '''-goi-''' cu ca'e co'e lo kulnu rafsi .i za'a so'i prenu cu xebni lo kulnu rafsi .i na'e jbosarxe .i to'e klunu'i .i na'e cumki fa lo nu ro remna kulnu cu co'e lo tordu rafsi .i ku'i nandu fa lo nu gasnu lo nu lo zasti poi kulnu rafsi cu co'u se pilno .i mi ca troci lo nu ba'e ''muvdu'' .i ra'oi '''-mer-''' pu rafsi zo merko .i ra'oi '''-mergoi-''' ca'e co'a rafsi zo merko .i zo merpre binxo zo mergoipre .i da'i sai! ba lo ba zu nu ra'oi '''-mer-''' poi lunbe cu co'u pilno fi tu'a zo merko kei cu co'a xamgu fa lo nu pilno ra'oi '''-mer-''' lo drata .i zmadu vajni fa lo za'i kakne lo nu finti lo klunu'i dunli clani rafsi be do'e lo vrici poi kulnu je poi jbovla tu'a ki fa lo po'o na'e gismu .i ra'oi '''-zoi-''' simsa ca'e je cu srana lo ku'i zifre canlu .i mu'a ra'oi '''-vanzoi-''' rafsi zo vanlamigu .i zo vanzoizga mu'a lujvo fo lu vanlamigu zgana li'u .i cizra .ie nai pei fa lo da'i nu lo fadni tordu cu rafsi zo vanlamigu .i mu'i finti lo sarxe barda poi cnino je poi rafsi canlu</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/lojbo_staile_liste&diff=112356User:Ramcinfo/lojbo staile liste2015-03-05T02:55:35Z<p>Ramcinfo: </p>
<hr />
<div>Principal purpose of this list is to explore ways to use Lojban different from Indo-European natlang ways.<br />
==Lojban-specific==<br />
* cmavo-only style<ref>[http://www.lojban.org/tiki/tiki-view_forum_thread.php?forumId=5&comments_parentId=7703&topics_offset=324&topics_sort_mode=lastPost_desc Lojban with only cmavo: an Oulipian strategy]</ref><br />
==Inspired by real language features==<br />
* {{vlapoi|sumcau|staile}}, inspired by nounless languages like that of Salishan and Wakashan families<ref>[https://www.dropbox.com/s/kvj63dtew6hs3z3/ENG%20Davidson%2CM.%20-%20Studies%20in%20southern%20Wakashan%20%28Nootkan%29%20grammar.pdf?dl=0 A grammar of Nootkah]</ref><ref>[https://en.wikipedia.org/wiki/Lojban#Syntax_and_semantics Example of Lojban imitating Nuu-chah-nulth] (near the end of the section). Note that it is also agglutinative.</ref>.<br />
==Inspired by other constructed languages==<br />
* Verbless style inspired by Kēlen<ref>[http://www.terjemar.net/grammar.php Kēlen Grammar]</ref><br />
* toki pona style, with e.g. anaphora instead of nested constructs ({mi pinxe lo tcati .i mi masno lonu go'i}). Vocabulary might or might not be restricted.<br />
==Inspired by fictional languages==<br />
* Tlön styles, from Borges’ short story. Most Tlön languages lack nouns, so sumti are either avoided or thought of as combinations of properties and/or relations. {{jvs|za'a}} and {{jvs|si'au}} evidentials are common.<br />
:* snanu .utloine staile: in Southern Tlön style, meaning is constructed from verbs and adverbs. Example:<br />
{{mu|mo'i ga'u ku ti'a lo zu'o ru'i flecu cu co'a mluni}}<br />
:* berti .utloine staile: in Northern Tlön style, objects are referred to by combination of adjectives (qualities). Possible lojbanic ways to do so: {{jvs|ka}} and {{jvs|za'i}} abstractions, modals making main level bridi into such abstractions (especially {{vlapoi|kai|ku}} and {{vlapoi|ri'i|ku}}, also {{vlapoi|ci'o|ku}} and {{vlapoi|mu'u|ku}}), {{vlapoi|ca'o|nai}} and {{vlapoi|co'i|nai}} event contours, {{jvs|ru'i}} and {{jvs|ze'e}} interval properties. Example:<br />
{{mu|kai vacri je gusni ne'i lo kai'u narju je kandi je tsani}}<br />
<br />
<br />
{{notci|Note: I am tempted to replace {lo zu'o} and {lo kai'u} with something other in these examples, to completely avoid references to (non-abstract) objects.}}<br />
* melaxoxengron staile, inspired by “language of dreams” in Max Frei novels. Similar to (especially Northern) Tlön style; default evidential is {{jvs|si'au}}, {{jvs|se'o}} may also be used.<br />
==Inspired by programming languages==<br />
* {{vlapoi|minde|sampla|staile}}, corresponding to imperative programming paradigm. Instead of claims, predicates are understood as commands. Some attempts are done here: [[Writing algorithms in Lojban]].<br />
* {{vlapoi|fancu|sampla|staile}}, corresponding to functional -"- -"- . Selbri understood as functions. See [[User:Ramcinfo/fancu_staile|the draft]].<br />
* {{vlapoi|logji|sampla|staile}}, corresponding to logical -"- -"- . Early draft is [[User:Ramcinfo/logji_staile|here]]. See also la jimpe<ref>http://web.mit.edu/~rspeer/Public/jimpe.pdf</ref>.<br />
* {{vlapoi|tinsa|tectaipe|staile}}, corresponding to strict typing.<br />
==Miscellaneous==<br />
* Stack staile, based on proglangs like Forth and PostScript and conlangs like [[Fith]] and Nalnuàntir<ref>http://conlang.wikia.com/wiki/Nalnu%C3%A0ntir</ref><br />
* Improvements of mekso, e.g. fancu bridi mekso proposal<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref><br />
=Credits=<br />
Many ideas were proposed by [[la gleki]].<br />
=References=<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/logji_staile&diff=112355User:Ramcinfo/logji staile2015-03-05T02:54:34Z<p>Ramcinfo: </p>
<hr />
<div>staile inspired by programming languages Prolog and Erlang.<br />
<br />
li no<br />
cu me'au la kancu me'u<br />
lo kutpoi<br />
<br />
lo'oi ke'a sumji li pa<br />
lo me'au la kancu me'u be da ku'au<br />
cu me'au la kancu me'u<br />
lo'oi ke'a konkatena vu'i zo'e da ku'au<br />
<br />
Equivalent definitions in Prolog and Erlang: http://danlucraft.com/blog/2007/08/comparing-erlang-and-prolog/<br />
<br />
See also: http://hyperpolyglot.org/logic<br />
<br />
I have doubts of defining sequence of single undefined element as {vu'i zo'e} — couldn’t zo'e be e.g. a set with cardinality > 1?</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/logji_staile&diff=112354User:Ramcinfo/logji staile2015-03-05T02:54:15Z<p>Ramcinfo: </p>
<hr />
<div>staile inspired by programming languages Prolog and Erlang.<br />
<br />
li no<br />
cu me'au la kancu me'u<br />
lo kutpoi<br />
<br />
lo'oi ke'a sumji li pa<br />
lo me'au la kancu me'u be da ku'au<br />
cu me'au la kancu me'u<br />
lo'oi ke'a konkatena vu'i zo'e da ku'au<br />
<br />
Equivalent definitions in Prolog and Erlang: http://danlucraft.com/blog/2007/08/comparing-erlang-and-prolog/<br />
See also: http://hyperpolyglot.org/logic<br />
<br />
I have doubts of defining sequence of single undefined element as {vu'i zo'e} — couldn’t zo'e be e.g. a set with cardinality > 1?</div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/lojbo_staile_liste&diff=112353User:Ramcinfo/lojbo staile liste2015-03-05T00:03:07Z<p>Ramcinfo: </p>
<hr />
<div>Principal purpose of this list is to explore ways to use Lojban different from Indo-European natlang ways.<br />
==Lojban-specific==<br />
* cmavo-only style<ref>[http://www.lojban.org/tiki/tiki-view_forum_thread.php?forumId=5&comments_parentId=7703&topics_offset=324&topics_sort_mode=lastPost_desc Lojban with only cmavo: an Oulipian strategy]</ref><br />
==Inspired by real language features==<br />
* {{vlapoi|sumcau|staile}}, inspired by nounless languages like that of Salishan and Wakashan families<ref>[https://www.dropbox.com/s/kvj63dtew6hs3z3/ENG%20Davidson%2CM.%20-%20Studies%20in%20southern%20Wakashan%20%28Nootkan%29%20grammar.pdf?dl=0 A grammar of Nootkah]</ref><ref>[https://en.wikipedia.org/wiki/Lojban#Syntax_and_semantics Example of Lojban imitating Nuu-chah-nulth] (near the end of the section). Note that it is also agglutinative.</ref>.<br />
==Inspired by other constructed languages==<br />
* Verbless style inspired by Kēlen<ref>[http://www.terjemar.net/grammar.php Kēlen Grammar]</ref><br />
* toki pona style, with e.g. anaphora instead of nested constructs ({mi pinxe lo tcati .i mi masno lonu go'i}). Vocabulary might or might not be restricted.<br />
==Inspired by fictional languages==<br />
* Tlön styles, from Borges’ short story. Most Tlön languages lack nouns, so sumti are either avoided or thought of as combinations of properties and/or relations. {{jvs|za'a}} and {{jvs|si'au}} evidentials are common.<br />
:* snanu .utloine staile: in Southern Tlön style, meaning is constructed from verbs and adverbs. Example:<br />
{{mu|mo'i ga'u ku ti'a lo zu'o ru'i flecu cu co'a mluni}}<br />
:* berti .utloine staile: in Northern Tlön style, objects are referred to by combination of adjectives (qualities). Possible lojbanic ways to do so: {{jvs|ka}} and {{jvs|za'i}} abstractions, modals making main level bridi into such abstractions (especially {{vlapoi|kai|ku}} and {{vlapoi|ri'i|ku}}, also {{vlapoi|ci'o|ku}} and {{vlapoi|mu'u|ku}}), {{vlapoi|ca'o|nai}} and {{vlapoi|co'i|nai}} event contours, {{jvs|ru'i}} and {{jvs|ze'e}} interval properties. Example:<br />
{{mu|kai vacri je gusni ne'i lo kai'u narju je kandi je tsani}}<br />
<br />
<br />
{{notci|Note: I am tempted to replace {lo zu'o} and {lo kai'u} with something other in these examples, to completely avoid references to (non-abstract) objects.}}<br />
* melaxoxengron staile, inspired by “language of dreams” in Max Frei novels. Similar to (especially Northern) Tlön style; default evidential is {{jvs|si'au}}, {{jvs|se'o}} may also be used.<br />
==Inspired by programming languages==<br />
* {{vlapoi|minde|sampla|staile}}, corresponding to imperative programming paradigm. Instead of claims, predicates are understood as commands.<br />
* {{vlapoi|fancu|sampla|staile}}, corresponding to functional -"- -"- . Selbri understood as functions. See [[User:Ramcinfo/fancu_staile|the draft]].<br />
* {{vlapoi|logji|sampla|staile}}, corresponding to logical -"- -"- . Early draft is [[User:Ramcinfo/logji_staile|here]]. See also la jimpe<ref>http://web.mit.edu/~rspeer/Public/jimpe.pdf</ref>.<br />
* {{vlapoi|tinsa|tectaipe|staile}}, corresponding to strict typing. Some attempts are done here: [[Writing algorithms in Lojban]].<br />
==Miscellaneous==<br />
* Stack staile, based on proglangs like Forth and PostScript and conlangs like [[Fith]] and Nalnuàntir<ref>http://conlang.wikia.com/wiki/Nalnu%C3%A0ntir</ref><br />
* Improvements of mekso, e.g. fancu bridi mekso proposal<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref><br />
=Credits=<br />
Many ideas were proposed by [[la gleki]].<br />
=References=<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/lojbo_staile_liste&diff=112352User:Ramcinfo/lojbo staile liste2015-03-04T23:56:09Z<p>Ramcinfo: </p>
<hr />
<div>Principal purpose of this list is to explore ways to use Lojban different from Indo-European natlang ways.<br />
==Lojban-specific==<br />
* cmavo-only style<ref>[http://www.lojban.org/tiki/tiki-view_forum_thread.php?forumId=5&comments_parentId=7703&topics_offset=324&topics_sort_mode=lastPost_desc Lojban with only cmavo: an Oulipian strategy]</ref><br />
==Inspired by real language features==<br />
* {{vlapoi|sumcau|staile}}, inspired by nounless languages like that of Salishan and Wakashan families<ref>[https://www.dropbox.com/s/kvj63dtew6hs3z3/ENG%20Davidson%2CM.%20-%20Studies%20in%20southern%20Wakashan%20%28Nootkan%29%20grammar.pdf?dl=0 A grammar of Nootkah]</ref><ref>[https://en.wikipedia.org/wiki/Lojban#Syntax_and_semantics Example of Lojban imitating Nuu-chah-nulth] (near the end of the section). Note that it is also agglutinative.</ref>.<br />
==Inspired by other constructed languages==<br />
* Verbless style inspired by Kēlen<ref>[http://www.terjemar.net/grammar.php Kēlen Grammar]</ref><br />
* toki pona style, with e.g. anaphora instead of nested constructs ({mi pinxe lo tcati .i mi masno lonu go'i}). Vocabulary might or might not be restricted.<br />
==Inspired by fictional languages==<br />
* Tlön styles, from Borges’ short story. Most Tlön languages lack nouns, so sumti are either avoided or thought of as combinations of properties and/or relations. {{jvs|za'a}} and {{jvs|si'au}} evidentials are common.<br />
:* snanu .utloine staile: in Southern Tlön style, meaning is constructed from verbs and adverbs. Example:<br />
{{mu|mo'i ga'u ku ti'a lo zu'o ru'i flecu cu co'a mluni}}<br />
:* berti .utloine staile: in Northern Tlön style, objects are referred to by combination of adjectives (qualities). Possible lojbanic ways to do so: {{jvs|ka}} and {{jvs|za'i}} abstractions, modals making main level bridi into such abstractions (especially {{vlapoi|kai|ku}} and {{vlapoi|ri'i|ku}}, also {{vlapoi|ci'o|ku}} and {{vlapoi|mu'u|ku}}), {{vlapoi|ca'o|nai}} and {{vlapoi|co'i|nai}} event contours, {{jvs|ru'i}} and {{jvs|ze'e}} interval properties. Example:<br />
{{mu|kai vacri je gusni ne'i lo kai'u narju je kandi je tsani}}<br />
<br />
<br />
{{notci|Note: I am tempted to replace {lo zu'o} and {lo kai'u} with something other in these examples, to completely avoid references to (non-abstract) objects.}}<br />
* melaxoxengron staile, inspired by “language of dreams” in Max Frei novels. Similar to (especially Northern) Tlön style; default evidential is {{jvs|si'au}}, {{jvs|se'o}} may also be used.<br />
==Inspired by programming languages==<br />
* {{vlapoi|minde|sampla|staile}}, corresponding to imperative programming paradigm. Instead of claims, predicates are understood as commands.<br />
* {{vlapoi|fancu|sampla|staile}}, corresponding to functional -"- -"- . Selbri understood as functions. See [[User:Ramcinfo/fancu_staile|the draft]].<br />
* {{vlapoi|logji|sampla|staile}}, corresponding to logical -"- -"- .<br />
* {{vlapoi|tinsa|tectaipe|staile}}, corresponding to strict typing.<br />
==Miscellaneous==<br />
* Stack staile, based on proglangs like Forth and PostScript and conlangs like [[Fith]] and Nalnuàntir<ref>http://conlang.wikia.com/wiki/Nalnu%C3%A0ntir</ref><br />
* Improvements of mekso, e.g. fancu bridi mekso proposal<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</ref><br />
=Credits=<br />
Many ideas were proposed by [[la gleki]].<br />
=References=<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/lojbo_staile_liste&diff=112351User:Ramcinfo/lojbo staile liste2015-03-04T23:54:36Z<p>Ramcinfo: </p>
<hr />
<div>Principal purpose of this list is to explore ways to use Lojban different from Indo-European natlang ways.<br />
==Lojban-specific==<br />
* cmavo-only style<ref>[http://www.lojban.org/tiki/tiki-view_forum_thread.php?forumId=5&comments_parentId=7703&topics_offset=324&topics_sort_mode=lastPost_desc Lojban with only cmavo: an Oulipian strategy]</ref><br />
==Inspired by real language features==<br />
* {{vlapoi|sumcau|staile}}, inspired by nounless languages like that of Salishan and Wakashan families<ref>[https://www.dropbox.com/s/kvj63dtew6hs3z3/ENG%20Davidson%2CM.%20-%20Studies%20in%20southern%20Wakashan%20%28Nootkan%29%20grammar.pdf?dl=0 A grammar of Nootkah]</ref><ref>[https://en.wikipedia.org/wiki/Lojban#Syntax_and_semantics Example of Lojban imitating Nuu-chah-nulth] (near the end of the section). Note that it is also agglutinative.</ref>.<br />
==Inspired by other constructed languages==<br />
* Verbless style inspired by Kēlen<ref>[http://www.terjemar.net/grammar.php Kēlen Grammar]</ref><br />
* toki pona style, with e.g. anaphora instead of nested constructs ({mi pinxe lo tcati .i mi masno lonu go'i}). Vocabulary might or might not be restricted.<br />
==Inspired by fictional languages==<br />
* Tlön styles, from Borges’ short story. Most Tlön languages lack nouns, so sumti are either avoided or thought of as combinations of properties and/or relations. {{jvs|za'a}} and {{jvs|si'au}} evidentials are common.<br />
:* snanu .utloine staile: in Southern Tlön style, meaning is constructed from verbs and adverbs. Example:<br />
{{mu|mo'i ga'u ku ti'a lo zu'o ru'i flecu cu co'a mluni}}<br />
:* berti .utloine staile: in Northern Tlön style, objects are referred to by combination of adjectives (qualities). Possible lojbanic ways to do so: {{jvs|ka}} and {{jvs|za'i}} abstractions, modals making main level bridi into such abstractions (especially {{vlapoi|kai|ku}} and {{vlapoi|ri'i|ku}}, also {{vlapoi|ci'o|ku}} and {{vlapoi|mu'u|ku}}), {{vlapoi|ca'o|nai}} and {{vlapoi|co'i|nai}} event contours, {{jvs|ru'i}} and {{jvs|ze'e}} interval properties. Example:<br />
{{mu|kai vacri je gusni ne'i lo kai'u narju je kandi je tsani}}<br />
<br />
<br />
{{notci|Note: I am tempted to replace {lo zu'o} and {lo kai'u} with something other in these examples, to completely avoid references to (non-abstract) objects.}}<br />
* melaxoxengron staile, inspired by “language of dreams” in Max Frei novels. Similar to (especially Northern) Tlön style; default evidential is {{jvs|si'au}}, {{jvs|se'o}} may also be used.<br />
==Inspired by programming languages==<br />
* {{vlapoi|minde|sampla|staile}}, corresponding to imperative programming paradigm. Instead of claims, predicates are understood as commands.<br />
* {{vlapoi|fancu|sampla|staile}}, corresponding to functional -"- -"- . Selbri understood as functions. See [[User:Ramcinfo/fancu_staile|the draft]].<br />
* {{vlapoi|logji|sampla|staile}}, corresponding to logical -"- -"- .<br />
* {{vlapoi|tinsa|tectaipe|staile}}, corresponding to strict typing.<br />
==Miscellaneous==<br />
* Stack staile, based on proglangs like Forth and PostScript and conlangs like [[Fith]] and Nalnuàntir<ref>http://conlang.wikia.com/wiki/Nalnu%C3%A0ntir</ref><br />
* Improvements of mekso, e.g. fancu bridi mekso proposal<ref>http://rossogilvie.id.au/essays/2013-01-22-fancu-bridi-mekso/</def><br />
=Credits=<br />
Many ideas were proposed by [[la gleki]].<br />
=References=<br />
<references/></div>Ramcinfohttps://mw.lojban.org/index.php?title=User:Ramcinfo/logji_staile&diff=112350User:Ramcinfo/logji staile2015-03-04T23:41:38Z<p>Ramcinfo: </p>
<hr />
<div>staile inspired by programming languages Prolog and Erlang.<br />
<br />
li no<br />
cu me'au la kancu me'u<br />
lo kutpoi<br />
<br />
lo'oi ke'a sumji li pa<br />
lo me'au la kancu me'u be da ku'au<br />
cu me'au la kancu me'u<br />
lo'oi ke'a konkatena vu'i zo'e da ku'au<br />
<br />
Equivalent definitions in Prolog and Erlang: http://danlucraft.com/blog/2007/08/comparing-erlang-and-prolog/<br />
<br />
I have doubts of defining sequence of single undefined element as {vu'i zo'e} — couldn’t zo'e be e.g. a set with cardinality > 1?</div>Ramcinfo