No problem, glad to help.
I just released new versions of both the package and plugin with some more
Windows fixes.
On Monday, 30 June 2014 15:31:28 UTC+1, Johan Sigfrids wrote:
Yes now I got it working. Thank you.
On Monday, June 30, 2014 5:19:02 PM UTC+3, Mike Innes wrote:
Ok, I need
?
On Monday, June 30, 2014 6:45:33 PM UTC+3, Mike Innes wrote:
No problem, glad to help.
I just released new versions of both the package and plugin with some
more Windows fixes.
On Monday, 30 June 2014 15:31:28 UTC+1, Johan Sigfrids wrote:
Yes now I got it working. Thank you.
On Monday, June
Great – if you want to minimise results just double click them, or right
click and select remove result to close them (or use the clear inline
results command to get rid of all of them at the same time). I really
recommend having a look through the wiki
.
On 30 June 2014 22:38, Alireza Nejati alireza@gmail.com wrote:
The weird thing though is that autocomplete works on non-julia files, it
just doesn't work with julia.
On Sunday, June 29, 2014 9:46:21 PM UTC+12, Mike Innes wrote:
Hey all,
I've released the latest version of the Julia
In terms of rich output in the recent release I really just threw together the
most basic thing that worked. For now that means there're going to be some
issues like this, but the good news is I'll be adding lots of frills and polish
for the next release.
Ideally I do want to support both
Just in case it's useful here's a function which I use:
function merge!(a::Dict, b::Dict)
for (k, v) in b
a[k] = v
end
return a
end
If you replace push! with merge! in your original example it should work as
expected.
On 27 July 2014 01:11, John Myles White johnmyleswh...@gmail.com
Regarding your point about function calls, this is actually something I
opened an issue about a while back, and it seems the consensus was against
it (although I do still think it would make sense, personally).
https://github.com/JuliaLang/julia/issues/7411
On 27 Jul 2014 18:29, Magnus Lie
...@googlemail.com wrote:
Isn't merge! already in the standard library?
On Sunday, July 27, 2014 11:24:36 AM UTC+1, Mike Innes wrote:
Just in case it's useful here's a function which I use:
function merge!(a::Dict, b::Dict)
for (k, v) in b
a[k] = v
end
return a
end
If you replace push
Hey all,
Following IPython's rename to Jupyter I've updated the name of the Jupiter
plugin in LT's plugin manager. If you have Jupiter or Jewel currently
installed in Light Table, please remove them from the plugin manager.
You can then reinstall the plugin by searching for Juno (the raw Julia
Glad you like it! I'm not seeing this, though – what's your version of
Jewel.jl? Did you Pkg.update()?
On 3 September 2014 17:21, David Smith david.sm...@gmail.com wrote:
Ok, the Ctrl-d doc shortcut is broken now. I get this error. Do I still
need the Jewel julia package?
I get a similar
at ./boot.jl:245
in include_from_node1 at loading.jl:128
in process_options at ./client.jl:285
in _start at ./client.jl:354
in _start at /Users/dsanders/development/julia/usr/lib/julia/sys.dylib
El miércoles, 3 de septiembre de 2014 15:58:54 UTC-5, Mike Innes escribió:
Hey
/dsanders/development/julia/usr/lib/julia/sys.dylib
El miércoles, 3 de septiembre de 2014 15:58:54 UTC-5, Mike Innes escribió:
Hey all,
Following IPython's rename to Jupyter I've updated the name of the
Jupiter plugin in LT's plugin manager. If you have Jupiter or Jewel
currently
2014 11:38, Job van der Zwan j.l.vanderz...@gmail.com
wrote:
Hmm, is there a way to set up LT so that it always runs Pkg.update() when
you boot it or before updating the Juno plugin? (not suggesting this as
default behaviour of course)
On Thursday, 4 September 2014 01:36:57 UTC+2, Mike Innes
So at the moment definitions (x = y etc.) are hidden, they just give you a
tick to show success.
You can still see the value by highlighting the x and evalling. There's no
option to change this at the moment, but I'm still playing around with it
so it's likely to change.
On 4 September 2014
Hey Erlend,
Thanks a lot for the detailed report. Honestly, PyPlot and terminal
integration aren't things I've tested much recently, so there's a good
chance I broke them at some point (sorry about that). Although the PyPlot
error is weird because it looks like an internal problem.
On the
, September 8, 2014 5:04:31 PM UTC+2, Mike Innes wrote:
Hey Erlend,
Thanks a lot for the detailed report. Honestly, PyPlot and terminal
integration aren't things I've tested much recently, so there's a good
chance I broke them at some point (sorry about that). Although the PyPlot
error
We can get really nice integration for Lint.jl and Light Table – I've
actually already got some of the GUI parts worked out, so it won't be crazy
difficult to do.
Quick question: How's Lint.jl's support for modules? For LT it's pretty
essential that the API looks like (block of code as text) +
Defining a starting line as a non-blank line which isn't preceded by
whitespace and isn't just end, what you want to do is to scan up from the
current cursor position to the first starting line. Then scan back down to the
first non-blank line before the next starting line, *or* the first end
Hi Thomas,
I've decided to wait until 0.4 has settled down a bit before supporting it
in Juno, so it's best to grab the latest release of Julia (v0.3). Building
from git should work fine but you could also try using the Ubuntu packages
That sounds like a bug – if you can it'd be great to open an issue with
more info (perhaps a screenshot/example) so I can look into it.
On 11 October 2014 15:20, Raul Durand raul.dur...@gmail.com wrote:
It works ok for me. Only issue is that Juno does not point the source line
where an error
This is the approach I often take in Juno when I need a terminal, although
it's not as well known or widely used, I think. But you can just connect to
a running terminal (or even IJulia) and evaluate from the file or the
terminal in the same context.
On Tuesday, 14 October 2014 00:28:55 UTC+1,
I had a go at embedding vt100.js (the terminal used for JuliaBox) in Light
Table. I just about managed to get it going UI-wise, but didn't manage to
get a bash/repl session going (I suspect you need to tell bash that you're
emulating a terminal or something, but really I have no idea about this
Ah ok, that's a nice trick too – I didn't know you could do that (although
it makes perfect sense).
Note that this also constructs the string at runtime, though.
On 18 November 2014 12:13, ele...@gmail.com wrote:
On Tuesday, November 18, 2014 7:40:53 PM UTC+10, Mike Innes wrote:
The basic
If you want to get the most out of Julia it might be best to unlearn the
Matlab practice of writing 500-line functions – this will probably solve a
lot of your problems. This might sound crazy, but I tend to treat anything
much longer than about 10 lines as code smell.
There are a whole bunch of
Whoops, I meant to say that string concatenation is not commutative, not
not associative... you know what I mean.
On 23 November 2014 at 20:40, Mike Innes mike.j.in...@gmail.com wrote:
If you want to get the most out of Julia it might be best to unlearn the
Matlab practice of writing 500-line
Woops, shouldn't have missed this thread.
Either way I just pushed 0.9.1 which turns off all rounding in display.
On Thursday, 20 November 2014 10:59:25 UTC, Ken B wrote:
for reference, here is the issue
https://github.com/one-more-minute/Julia-LT/issues/114
I've been bitten by this one
One good reason to use Light Table is that it has pretty good support for
using Julia interactively. Things like eval'ing the current code block in
the editor, highlighting and linking to lines that cause errors, support
for eval in modules, inline Gadfly plots etc. See here http://junolab.org/
if
Krysl krysl.p...@gmail.com wrote:
Hi Mike,
I installed LT and ran it on my toy Julia project. I tried to make the
connection to Julia, but I couldn't find it on the list. What do I do?
Thanks,
Petr
On Saturday, November 29, 2014 7:30:05 AM UTC-8, Mike Innes wrote:
One good reason
,
I installed LT and ran it on my toy Julia project. I tried to make the
connection to Julia, but I couldn't find it on the list. What do I do?
Thanks,
Petr
On Saturday, November 29, 2014 7:30:05 AM UTC-8, Mike Innes wrote:
One good reason to use Light Table is that it has pretty good
use voice recognition to drive my PC, and the
key bindings are used to execute commands that I say). So I can see how
the learning curve can seem pretty steep!
On Saturday, November 29, 2014 10:42:18 AM UTC-8, Mike Innes wrote:
The errors there are from installing the plugins (a known issue
The way to find this is to start typing part of the name of the command,
e.g.
[:editor ctrl-3 smart|]
It should fuzzy search through the available commands and give you an
autocomplete prompt with the command you want. Then you can just press
`tab` to select it and it will enter
, but in Linux ALT will drag the whole window, not the cursor.
On Saturday, November 29, 2014 4:30:05 PM UTC+1, Mike Innes wrote:
(PS Hans: You can do block selection in LT by dragging with the alt key)
To also clarify on why @sprintf behaves this way, the reason is that it
compiles down to specialised code for printing e.g. a float, followed by a
double, etc., whatever you specify. If you use a variable like `fmt` the
actual value is only available long after the code has already been
compiled.
Or p = Vector{Int}[[1,2,3],[4,5,6]]
On 3 December 2014 at 13:41, Simon Danisch sdani...@gmail.com wrote:
You mean like this?
q = Array(Array{Int}, 2) # 2 - space for two arrays... otherwise use 0
and push!(q, [1,2,3])
q[1] = [1,2,3];q[2]=[2,3,4]
this works as well:
Array{Int}[[1,2,3],
#9423 https://github.com/JuliaLang/julia/pull/9243 should help with the
repetition of format strings issue. It occurs to me now that you can always
just write a function wrapper for `@sprintf` to solve that issue but this
might still be useful.
On Wednesday, 3 December 2014 01:40:56 UTC,
I suspect Tim's idea was to help out by closing issues, not by opening them.
On 5 December 2014 at 15:36, Páll Haraldsson pall.haralds...@gmail.com
wrote:
On Friday, December 5, 2014 2:39:11 PM UTC, Tim Holy wrote:
I'm glad you're enthusiastic about Julia. If you're looking to pitch in,
I'll add some meta-documentation to the manual for this soon.
On 5 December 2014 at 19:58, John Myles White johnmyleswh...@gmail.com
wrote:
Documentation is undergoing a shift as 0.4 will be the first release with
built-in documentation tools. Check the GitHub issues for details about the
I can close that issue for a case of beer, although I can't promise to
actually fix it.
On 5 December 2014 at 20:49, Tim Holy tim.h...@gmail.com wrote:
Sounds like a bargain...count me in for a bottle.
--Tim
On Friday, December 05, 2014 03:22:18 PM Stefan Karpinski wrote:
Make it a bottle
Think of append!(X, Y) as equivalent to X = vcat(X, Y). You called append!
twice, so X gets Y appended twice.
julia X = [1,2]; Y = [3,4];
julia X = vcat(X,Y)
[1, 2, 3, 4]
In your example you went ahead and did this again:
julia X = (X = vcat(X, Y))
[1, 2, 3, 4, 3, 4]
But if you reset X, Y via
You can do this just fine, but you have to be explicit about what variables
you want to pass in, e.g.
let x=2
exp=:(x+1)
eval(:(let x = $x; $exp; end))
end
If you want to call the expression with multiple inputs, wrap it in a
function:
let x=2
exp=:(x+1)
f = eval(:(x - $exp))
f(x)
end
It seems to me that a lot of FAQs could be answered by a simple list of the
communities'/core developers' priorities. For example:
We care about module load times and static compilation, so that's going to
happen eventually. We care about package documentation, which is basically
done. We don't
https://github.com/JuliaLang/julia/issues/4964
On 11 December 2014 at 11:55, Uwe Fechner uwe.fechner@gmail.com wrote:
What do you mean with TCO?
On Thursday, December 11, 2014 10:50:19 AM UTC+1, Mike Innes wrote:
It seems to me that a lot of FAQs could be answered by a simple list
should have waited to look at the next day
before asking for help; it seems obvious now.
-- Sean
On Thursday, December 11, 2014 3:26:12 AM UTC-6, Mike Innes wrote:
Think of append!(X, Y) as equivalent to X = vcat(X, Y). You called
append! twice, so X gets Y appended twice.
julia X = [1,2
!
Mike
On Thursday, December 11, 2014 10:34:22 PM UTC+13, Mike Innes wrote:
You can do this just fine, but you have to be explicit about what
variables you want to pass in, e.g.
let x=2
exp=:(x+1)
eval(:(let x = $x; $exp; end))
end
If you want to call the expression with multiple
community? I thought the paradigm Julia favors is loops and maybe
some functional code.
Best,
Tamas
On Thu, Dec 11 2014, Mike Innes mike.j.in...@gmail.com wrote:
https://github.com/JuliaLang/julia/issues/4964
On 11 December 2014 at 11:55, Uwe Fechner uwe.fechner@gmail.com
wrote:
What
This just happens because the docs are pulled straight out of the manual
http://docs.julialang.org/en/latest/stdlib/base/#Base.ifft, which is
written in restructured text. The repl help mode doesn't do any processing
on the source so you get that.
We're in the process of moving to a
I believe this is so that you can do a sort of search through history – if
the cursor is after the letter a you'll find that you only go up through
lines beginning with a.
FWIW, I really dislike this new behaviour as well. Aside from being less
convenient it breaks going back down; I can no
You're right, that's a huge improvement. Kudos to Blake Johnson.
On 16 December 2014 at 11:32, Harold Cavendish harrold.cavend...@gmail.com
wrote:
It was commit b5f94b6 (5 days old master) and you're right, the newest
version is different, and as far as I'm concerned splendid!
Thanks for the
Actually the @doc macro will still interpret plain strings as markdown by
default. There are some caveats with escaping that make it good practice to
write doc anyway, but those will go away once the parser changes are
implemented.
I'm in the process of writing documentation documentation, so the
that will allow documented code to still compile in 0.3?
Cheers
Lex
On Wednesday, December 17, 2014 8:04:06 AM UTC+10, Mike Innes wrote:
Actually the @doc macro will still interpret plain strings as markdown by
default. There are some caveats with escaping that make it good practice to
write doc anyway
It is needed if you want the docs to show up in the repl etc. It's just
that the plain string won't break anything (it won't do anything, either,
for now).
On 16 December 2014 at 22:58, ele...@gmail.com wrote:
On Wednesday, December 17, 2014 8:41:00 AM UTC+10, Mike Innes wrote:
It's
If it helps at all, I saw that exact issue a few days back, on 0.3 and 0.4.
I had to delete and rebuild the openblas included in the Julia repo. I
don't know exactly how the Julia 0.3.x builds work but a stale openblas may
be causing issues.
On 26 December 2014 at 16:13, Tony Kelman
None of those are particularly good reasons. It boils down to Julia
doesn't do Java-style OO well, but believe it or not Java-style OO isn't
the only way you can build a large program.
To take a couple of specific points as examples, you can use composition
Who cares how impressive the code is when the result looks that good? ;)
This is really nice and I might have to print a copy for myself, if that's
alright with you. Happy new year to you too!
On 27 December 2014 at 09:38, cormull...@mac.com wrote:
I used Julia to make my Christmas presents
I can only speculate about the reason that people still use include, even
though Julia has nice modules.
Well, I for one think that
1) Modules containing a large number of functions are OK (and this is very
common in more functional languages)
2) If you're going to have (1), you want to
Slightly OT, but I imagine the try/catch Dan refers to is the display
system. Unfortunately it is a horribly brittle way to implement that code
that still now has the potential to cause bugs (due to the fact that you
can't tell where in the stack the error came from). I'm prototyping
something to
I hope we'll one day have ObjectiveC.jl running on iOS, but that day is a
long way off.
On 30 December 2014 at 02:06, Stefan Karpinski ste...@karpinski.org wrote:
You'd have to get Julia running on a mobile phone first, which we may be
getting close to but as far as I know has not been
for compute
within a mobile app should be pretty feasible in the not-so-distant future.
peace,
s
On Tue, Dec 30, 2014 at 9:50 AM, Mike Innes mike.j.in...@gmail.com
wrote:
I hope we'll one day have ObjectiveC.jl running on iOS, but that day is a
long way off.
On 30 December 2014 at 02:06
On Tue, Dec 30, 2014 at 12:09 PM, Mike Innes mike.j...@gmail.com
wrote:
In principle, although last time I checked Apple doesn't allow apps to
use JIT compilation, so we'd need fully static compilation first. I
don't
know exactly what the precompilation roadmap looks like, but my
What if the file name is only known at run time?
I'm all for better lint and warning tools to help those who want to remove
type stability, but bear in mind that not everyone does. I for one really
like the convenience of dynamic typing for non-performance-sensitive code.
On 3 January 2015 at
There is type instability here, actually – the macro doesn't change
anything with regard to types.
coltype = get_vector_coltype_from_file(filename)::?
load_vector_from_hdf5_file(filename, vecname, coltype)::?
get_vector... is not type stable, which means that the entire block isn't –
there's no
Right, so you have the high-level, dynamic part of the language for basic
interactive use and the harder to use, fully typed part for the real
coding.
Except that already exists – you can just use Python and C. The split
between high and low-level is exactly the problem that Julia was designed
to
It's not an inherent feature of Julia, no, just a tooling thing. Juno, for
example, will allow you to eval directly into modules just fine, including
defining new functions, replacing them, evalling `include`s, and replacing
the module wholesale in order to get around type redefinition issues and
functions
into a module in the REPL?
Best,
Tamas
On Mon, Jan 26 2015, Mike Innes mike.j.in...@gmail.com wrote:
It's not an inherent feature of Julia, no, just a tooling thing. Juno,
for
example, will allow you to eval directly into modules just fine,
including
defining new functions
I don't know why the word functor was originally used in Julia for
function-like type, but it doesn't seem to have anything to do with the
functional programming / haskell / category theory functor (or any
particular relevance to monads). Might be a good idea to use a different
term since it
First, try opening a Terminal window and launching `git`. You should find
it asks you to agree to an apple license or something similar, and after
that Juno should work.
If not, if you press `Ctrl-Space` to open the command bar, type open
terminal and Enter, a plain Julia REPL should launch. From
Hey Julians,
Just wanted to drop a note to say that the new documentation system now has
some of its own documentation in the manual
http://docs.julialang.org/en/latest/manual/documentation/. This will be
relevant even if you're not using 0.4, since you can use the excellent
Docile.jl package to
quote...end is effectively the same as :(being ... end), that's all.
I think you probably want something more like
macro nb(f, args...)
:($f($(args...))) | esc
end
since the function `f` should also be resolved at the call site.
On 15 January 2015 at 03:39, yi lu
The Juno forum isn't dead but is is unfortunately a bit slow, which
basically comes down to the fact that there are far fewer people who know a
lot about its internals (and most of them have other commitments, at least
for the very near future). I try to respond to everything within a few
days, or
No problem, glad you like it!
On 11 February 2015 at 16:52, Christoph Ortner christophortn...@gmail.com
wrote:
ah - just saw your reply there
http://discuss.junolab.org/t/julia-0-4-docile-doc-strings/120/2
Thanks a lot!
Also: I am quite enjoying working with Juno, even though I normally
If you use Juno you can eval into modules directly, without having to
reload them, which makes stuff like this a lot nicer. AFAIK there's no
other way to work around this, but I'd love to be corrected on that.
On 18 February 2015 at 08:53, Tamas Papp tkp...@gmail.com wrote:
Hi,
I thought that
This is something I've been thinking about as well, and overloading `print`
etc. to work with markdown is definitely doable. I'm not sure how it would
work in IJulia, but it would definitely be ok in the terminal.
Use md unless you're writing inline docs (you might have to do a using
No, feel free to open one if you want (ping me too).
On 1 February 2015 at 12:18, Christoph Ortner christophortn...@gmail.com
wrote:
Is this an existing issue somewhere?
On Sunday, 1 February 2015 12:18:42 UTC, Christoph Ortner wrote:
Thanks for the clarification. It would be really great
Markdown.jl lives in base Julia now so it should probably go there.
On 1 February 2015 at 15:18, Christoph Ortner christophortn...@gmail.com
wrote:
should this go in Docile, Lexicon, or Julialang?
Christoph
Juno works a little differently to Matlab – evaluation is done within the
editor itself. If you right click an expression (like 2+2) and select
evaluate you should see the result come up next to it. (You can also use
Ctrl-Enter, which is a bit quicker)
Do you see a tutorial? One should come up on
You can also open a REPL connected to Juno
http://junolab.org/docs/terminal.html very easily. It's still a little
more awkward than an integrated console could be but it's often useful.
On 5 January 2015 at 13:37, yu...@altern.org wrote:
Usually I have a second file open that I use like a
Hello Julians,
I have a shiny late Christmas present for you, complete with Julia-themed
wrapping.
Blink.jl https://github.com/one-more-minute/Blink.jl wraps Chrome to
enable web-based GUIs. It's very primitive at the moment, but as a proof of
concept it includes BlinkDisplay, which will display
%2B7.17.29%2Bpm.png
On Monday, January 5, 2015 10:30:33 PM UTC+8, Mike Innes wrote:
Hello Julians,
I have a shiny late Christmas present for you, complete with Julia-themed
wrapping.
Blink.jl https://github.com/one-more-minute/Blink.jl wraps Chrome to
enable web-based GUIs. It's very
Well, the abstraction is already there – you can call JS
https://github.com/one-more-minute/Blink.jl/blob/3baa5c6b7ea035a2bb3fa3faad95d3f74aba2f26/src/window.jl#L103-L104
pretty directly
https://github.com/one-more-minute/Blink.jl/blob/3baa5c6b7ea035a2bb3fa3faad95d3f74aba2f26/src/window.jl#L68-L72
You can override the `call` function to do just this, but the behaviour is
new to 0.4.
On 10 January 2015 at 14:04, Ed Scheinerman edward.scheiner...@gmail.com
wrote:
I'm working on a type that will have a function-like behavior, so I'd like
to write f(x) to evaluate the function f at x. I
That's very cool. You should definitely package this up if you can. The
JS-on-top approach might actually make it easier to package up a Julia app,
at least in the short term. (Also, if you don't want to call julia.eval
every time, it should be easy to hook up the Julia instance to Juno and use
it
Cool. $(symbol(gen_$x)) might also be a bit more compact, now I think
about it.
On 7 January 2015 at 02:00, Chi-wei Wang cwwang...@gmail.com wrote:
Exactly what I want! Thanks!
Mike Innes於 2015年1月7日星期三UTC+8上午9時34分21秒寫道：
Is $(symbol(string(gen_, x))) what you're looking for?
On 7 January
Sure, I mainly mentioned libc'c' because it's what atom-shell uses, but CEF
looks good too. I actually had a go with CEF myself but with my limited C
experience it was way too fiddly – getting it working well on all platforms
would've taken me years.
Thinking about it more, Chromium uses a
Is $(symbol(string(gen_, x))) what you're looking for?
On 7 January 2015 at 01:28, Chi-wei Wang cwwang...@gmail.com wrote:
Hi, everyone.
I'd like to do something like following C code in Julia.
#define gen_func(x) \
void f_##x() { \
}
I tried the following Julia code, but I have no idea
Using $(args...) should do the trick, I think.
On 14 January 2015 at 09:20, yi lu zhiwudazhanjiang...@gmail.com wrote:
Hi,
I want to write a macro which works as map function.
It should work for these.
```
@map x-x+1 1:10
@map + 1:10 11:20
```
I know it is just copying the argument
at 5:23 PM, Mike Innes mike.j.in...@gmail.com
wrote:
Using $(args...) should do the trick, I think.
On 14 January 2015 at 09:20, yi lu zhiwudazhanjiang...@gmail.com wrote:
Hi,
I want to write a macro which works as map function.
It should work for these.
```
@map x-x+1 1:10
@map + 1:10
Or, indeed, just parse the expression and pull the data out directly,
avoiding the dangerous eval step entirely. That will most likely be faster,
too.
On 12 January 2015 at 16:01, Steven G. Johnson stevenj@gmail.com
wrote:
On Monday, January 12, 2015 at 2:42:59 AM UTC-5, Ivar Nesje wrote:
An underscore is basically the only option here, seeing basically every
other operator imaginable is taken.
Still, I'm personally happy with the current convention of underscore_case
alongside squished case where it doesn't hurt readability.
I agree that things like `searchsortedlast` could
Have you met @show?
On 4 January 2015 at 11:10, ele...@gmail.com wrote:
I think you need a macro, something like:
macro printvar(var)
return :(print($(string(var))); print(=); println($var))
end
julia a=2
2
julia @printvar a
a=2
Cheers
Lex
On Sunday, January 4, 2015
I'm not that familiar with HTTPClient.jl specifically, but usually if you
have a stream of data you can do
JSON.parse(io)
in a loop, and it will only block until the next JSON object is finished.
Julia doesn't do much that's Clojure-like by default but you may be
interested in Lazy.jl
To reiterate, static typing and type stability (in the Julia sense) are *not
the same concept*. To take an example from that ML Markdown parser:
type paragraph =
Normal of par_text
| Pre of string * string option
| Heading of int * par_text
| Quote of paragraph list
| Ulist of
Oh yeah, of course – I think OCaml has one as well. Although Haskell's at
least is interpreted rather than JIT-compiled, so it's nowhere near as nice
to use as Julia's ;)
You should also check out Leah Hanson's work on TypeCheck.jl
https://github.com/astrieanna/TypeCheck.jl, if you haven't seen
The writemime methods and the display system are largely orthogonal – the
display system concerns itself with routing output to a suitable display
device (terminal, Blink window, whatever) while writemime simply provides
the implementation. In other words, I'm only really focused on the
`display`
func{T:Foo}(bar::T)
should do what you want, I think
On 5 January 2015 at 18:28, Samuel Colvin samcol...@gmail.com wrote:
julia abstract Foo
julia type SubFoo : Foo
x
end
julia func(bar::Type{Foo}) = println(bar)
func (generic function with 1 method)
julia f=SubFoo(1)
be:
func{T:Foo}(bar::Type{T}) ...
On Mon, Jan 5, 2015 at 11:30 AM, Mike Innes mike.j.in...@gmail.com
wrote:
func{T:Foo}(bar::T)
should do what you want, I think
On 5 January 2015 at 18:28, Samuel Colvin samcol...@gmail.com wrote:
julia abstract Foo
julia type SubFoo : Foo
x
(USE64BITINT DYNAMIC_ARCH NO_AFFINITY Sandybridge)
LAPACK: libopenblas
LIBM: libopenlibm
LLVM: libLLVM-3.3
*julia *
On Jan 5, 2015, at 6:29 AM, Mike Innes mike.j.in...@gmail.com wrote:
Hello Julians,
I have a shiny late Christmas present for you, complete with Julia-themed
wrapping
Try a Pkg.update() from the Julia REPL.
On 8 January 2015 at 10:02, Pengfei Zhang pengfei.zhang@gmail.com
wrote:
When I'm trying to run Juno in Mac OSX 10.10.1 Yosemite, I got:
Couldn't connect to Julia
ERROR: `server` has no method matching server(::Int64, ::Int64, ::Bool)
in server
In eval clients like Juno autocomplete locks up while evaluating, so that's
something I'm looking forward to solving with some thready goodness. Not
quite GUI as such but close.
On 18 Mar 2015 18:12, Sebastian Good sebast...@palladiumconsulting.com
wrote:
Task stealing parallelism is an
This seems to happen on OS X occasionally, for some reason. What you can do
is try the open a terminal repl command which will open a plain copy of
the version of Julia that Juno is running from. You should be able to
`Pkg.update()` from there, but if you see another error then let us know.
On 17
The distance between Julia and insanity is measured only in segfaults
101 - 200 of 283 matches
Mail list logo
