<BertolucciTalks>
Yeah I actually saw that part but the partial application is technically implemented with floats in that example
<BertolucciTalks>
more crucially than any function techniques, so i guess i should revise the question, "Can you pass in functions explicitly into parameters of functions?"
<BertolucciTalks>
thank you for the reference; I appreciate your time btw :)
<SeanTAllen>
Is the meetup on the 11th Andy's tutorial at jet BertolucciTalks ?
<SeanTAllen>
If you are looking for an FP language, you probably won't like Pony.
<SeanTAllen>
So, it really depends on what you mean by "pass functions explicitly". There are no free floating functions in Pony.
<SeanTAllen>
If you have a function that takes "a function" as a parameter than you could satisfy with a lambda, an object literal or a primitive.
<SeanTAllen>
if you are familiar with OCaml, primitives are a bit like OCaml modules (although most Pony users dont have the background to recognize that)
<SeanTAllen>
If you are looking for a language that is rather different than what you know, I would suggest going to the Pony meetup. You will be presented with more ideas from it that you probably arent familiar with than if you went to the Kotlin meetup.
endformationage has quit [Ping timeout: 256 seconds]
BertolucciTalks has joined #ponylang
BertolucciTalks has quit [Ping timeout: 276 seconds]
BertolucciTalks has joined #ponylang
khan has quit [Quit: khan]
bimawa has joined #ponylang
Lumba has joined #ponylang
Lumba has quit [Ping timeout: 252 seconds]
vaninwagen_ has joined #ponylang
PrsPrsBK has quit [Quit: PrsPrsBK]
vaninwagen_ has quit [Ping timeout: 264 seconds]
PrsPrsBK has joined #ponylang
alxs has joined #ponylang
alxs has quit [Quit: Computer's gone to sleep. ZZZzzz…]
bimawa1 has quit [Quit: WeeChat 1.9.1]
_andre has joined #ponylang
alxs has joined #ponylang
dipin has joined #ponylang
kempe has quit [Quit: WeeChat 1.8]
kempe has joined #ponylang
SenasOzys has joined #ponylang
SenasOzys has quit [Remote host closed the connection]
SenasOzys has joined #ponylang
jaro has joined #ponylang
endformationage has joined #ponylang
alxs has quit [Quit: Computer's gone to sleep. ZZZzzz…]
alxs has joined #ponylang
alxs has quit [Ping timeout: 256 seconds]
alxs has joined #ponylang
alxs has quit [Client Quit]
SenasOzys has quit [Ping timeout: 256 seconds]
khan has joined #ponylang
endformationage has quit [Ping timeout: 260 seconds]
alxs has joined #ponylang
alxs has quit [Client Quit]
alxs has joined #ponylang
alxs has quit [Quit: Computer's gone to sleep. ZZZzzz…]
alxs has joined #ponylang
SenasOzys has joined #ponylang
alxs has quit [Quit: Computer's gone to sleep. ZZZzzz…]
jdhorwitz has quit [Quit: Connection closed for inactivity]
user10032 has joined #ponylang
<BertolucciTalks>
@SeanTAllen, endformationage thank you so much for clarification! yes its the one at Jet; I'm gonna go anyway cuz pony cuz still looks awesome!
<SeanTAllen>
BertolucciTalks: I might be there with Andy.
alxs has joined #ponylang
<strmpnk>
I've been updating the void linux ponyc and pony-stable packages. One item on my list is to get the musl port working. There are two small stumbling blocks: ALPINE specific defines (we should probably be more specific about musl or use feature detection scripts) and LLVM3.9 is busted on musl on void linux.
<strmpnk>
The latter I might address but may potentially require a lot of work overhauling that package.
<strmpnk>
So I was wondering what the status of vendoring LLVM was.
<strmpnk>
Perhaps it'd be worth waiting on that instead.
<SeanTAllen>
Vendoring LLVM is close
<SeanTAllen>
Plan is to release first as vendored but external available as well
<SeanTAllen>
Once vendored issues are worked out, drop support for external, non vendored.
<SeanTAllen>
And then we can do any LLVM 3.9.1 patching we want
<SeanTAllen>
And eventually, upgrade to a newer LLVM after we patch bugs and submit upstream
<strmpnk>
Sounds good. I'll wait since I'd like to avoid diving into recompiling lots of packages in void to test patches.
<SeanTAllen>
Sounds reasonable
alxs has quit [Ping timeout: 248 seconds]
endformationage has joined #ponylang
BertolucciTalks has quit [Quit: Off to find the sleeping bear...]
alxs has joined #ponylang
user10032 has quit [Quit: Leaving]
alxs has quit [Quit: Computer's gone to sleep. ZZZzzz…]
alxs has joined #ponylang
alxs has quit [Quit: Computer's gone to sleep. ZZZzzz…]
ponynoob has joined #ponylang
<ponynoob>
a question about types - the clone method in Array is defined as fun clone(): Array[this->A!]^
<ponynoob>
does that mean it returns an iso^? or a ref^? (let's say my Array is a ref)
jbk has quit [Read error: Connection reset by peer]
jbk has joined #ponylang
<SeanTAllen>
if your Array is a ref then it will return a ref->A! so for the sake of a beginner, let's call that a ref.
<SeanTAllen>
the "this->" is "viewpoint adaptation" or basically, "it depends based on the ref cap of the Array in question, the "this"
<SeanTAllen>
ponynoob: hope that helps
<ponynoob>
that clarifies the capability of the generic parameter, but what about the overall object? i.e. do i get a Array[? ref] iso^ or a Array [? ref] ref^?
<SeanTAllen>
you can an Array[ref->A!]
<SeanTAllen>
so... the A!
<SeanTAllen>
is
<SeanTAllen>
A for the items that are the type of the Array
<SeanTAllen>
So les say Array[String] it would be
<SeanTAllen>
Array[ref->String!]
<SeanTAllen>
the ! means its an alias
<SeanTAllen>
clone doesn't do a deep clone. that is the !.
<SeanTAllen>
if you want a deep clone, you need to implement yourself
<ponynoob>
what does the ^ in the definition of clone mean?
<SeanTAllen>
ephemeral
<ponynoob>
i've seen examples where methods return iso^, but not ^ by itself
<ponynoob>
is there any difference between a lone ^ (without iso) and iso^?
<SeanTAllen>
right ^ means basically "giving up my alias to this"
<SeanTAllen>
you can't have ^ by itself
<SeanTAllen>
iso^ means there's only one alias to this AND i'm giving mine up
<ponynoob>
i've read them both, but both of them have iso^ but not ^ (that is, ^ without "iso" or "ref" or any other capability) - if there is no capability, does it default to ref in this case? that is, Array[...]^ is the same as Array[...] ref^
<ponynoob>
(or are my questions just showing that i should be reading more about this topic first)
<SeanTAllen>
no
<SeanTAllen>
it is whatever the default for that type is
<SeanTAllen>
here is the definition of array...
<SeanTAllen>
"class Array[A] is Seq[A]"
<SeanTAllen>
there's an implicit "ref" in there
<SeanTAllen>
"class ref Array[A] is Seq[A]"
<SeanTAllen>
however...
<SeanTAllen>
class val String is (Seq[U8] & Comparable[String box] & Stringable)
<SeanTAllen>
that "val" means teh default reference capability for "String" is "val" if one isn't supplied
<SeanTAllen>
so
<SeanTAllen>
let a: String
<SeanTAllen>
is
<SeanTAllen>
let a: String val
<SeanTAllen>
let a: Array
<SeanTAllen>
is
<SeanTAllen>
let a: Array ref
<SeanTAllen>
if I want a String ref i would need to do
<SeanTAllen>
let a: String ref
<ponynoob>
ok, so since Array defaults to ref, `let a = Array[U8]; let b = a.clone()` -> the type of b is "Array[U8] ref" right?
<ponynoob>
(and by "Array[U8] ref" i mean "Array[U8 val] ref")
<SeanTAllen>
yes
<ponynoob>
is there any reason why clone wasn't defined to return Array[U8 val] iso^ in this case?
<SeanTAllen>
i think you've gone a step to far there
<SeanTAllen>
its defined to Array[this->A!]
<SeanTAllen>
if A was String ref
<SeanTAllen>
then you cant do iso^
<SeanTAllen>
unless you have a cloneable interface
<SeanTAllen>
and you require everything in an array to be "Cloneable"
<SeanTAllen>
and have a clone() method
<SeanTAllen>
so you could do a deep clone
<SeanTAllen>
Array[U8 val!] is a single reification. iso^ would only make sense on machine words or if everything had to be "cloneable"
<ponynoob>
`let a = Array[String ref]; let b = a.clone()` - i was thinking that it would make sense for b to be Array[String ref] iso, but i guess that's not true, since such an array would be quite difficult to use (you have to destructively read if you want to get anything other than a tag)
<ponynoob>
ok, thanks for all your explanations
<SeanTAllen>
being able to do different things based on the reference capabiility is an ongoing topic of conversation