Re: Types of languages Re: [racket-users] the list of languages made with racket [Hacker News]

[Justin Zamora]

You should include Danny Yoo's Brainfudge in the "stand-alone
languages with non-s-exp syntax".
https://www.hashcollision.org/brainfudge/index.html

Justin

On Fri, Mar 1, 2019 at 6:15 PM Stephen De Gabrielle
 wrote:
>
>
>
> On Fri, 1 Mar 2019 at 18:00, Matthias Felleisen  
> wrote:
>>
>>
>>
>> > On Mar 1, 2019, at 12:05 PM, Stephen De Gabrielle 
>> >  wrote:
>> >
>> > Hi Matthias,
>> > (or anyone else who is available to answer :))
>> >
>> > I'm trying to get my head around the range of possible languages in Racket.
>> >
>> > You got me thinking how many languages seem to have embedded little 
>> > languages.
>> > I was wondering how they fit into your categories of languages?
>> >
>> > 3. The nature of languages ranges from
>> > — stand-alone languages with ugly syntax (example: datalog)
>> > — #lang stand-alone DSLs (config, scribble)
>> >
>> > Does '#lang video' fit in this group?
>>
>> Yes.
>>
>>
>> >
>> > — #lang language mixins (s-expr, 2d)
>> >
>> > Do regular #px""/#rx expressions fit in this category?
>>
>> I don’t understand how #px is similar to the s-expr or at-expr or 2d #lang 
>> mixins. I am referring to lines such as #lang at-exp scribble.
>>
>> [...]
>> p.s. In my mind, format and regexp-match (and similar functions) are 
>> interpreters for programs in DSLs that are written down as strings. That’s 
>> my opening slides for HtDL (from last year).
>
>
> The example from Greg Hendershot, below, gave the impression they were like 
> at-exp and the #2dcond syntax extension seems to fit the same pattern as #px 
> , but I see what you mean about regex-match and format being interpreters.
> @pregexp{\d\.\d}  ; #px"\\d\\.\\d"  (from 
> https://www.greghendershott.com/2015/08/at-expressions.html )
> (I do use that trick to make regexp more readable - at-exp is great)
>
> leaving aside my confusion, my goal here is to a page to the racket website 
> that showcases an selection of languages made with Racket, that is better 
> than a search of things that define a #lang
>
> #lang stand-alone languages with non-s-exp syntax (I'm inclined not to 
> include 'ugly syntax' on a PR for the racket website)
>
> Algol 60
> Datalog
> Scratchy
> ProfessorJ (deliberately included as ~30% of job ads in the UK specify Java)
> Rash: The Reckless Racket Shell
> Riposte
>
> #lang stand-alone DSLs (config?, scribble)
>
> (I don't know a 'config' lang apart from #lang info)
>
> Scribble
> Hackett
> Heresy
> Lindenmayer
> Parenlog
> Pie
> Video
>
>
> #lang language mixins (s-expr, 2d)
>
> #lang s-exp [module]
> #lang 2d racket
> #lang at-exp
>
> embedded DSLs with mostly coarse-grained interactions with Racket (redex)
>
> Redex (require redex)
> [need to identify another example]
>
>
> embedded DSLs with fine-grained interaction with Racket (the language of 
> class syntax; syntax-parse: the pattern and templated languages, which 
> interact via syn-pattern vars)
>
> (require racket/class)
> syntax-parse
> syntax-case patterns and templates etc.
>
>
> string interpreters
>
> regexp
> format
>
>
> Languages with other targets
>
> Asi64
> Pollen
> Scribble (?)
> Racket-script
>
>
> Are these good categories?
>
> Kind regards,
>
> Stephen
>
> --
> You received this message because you are subscribed to the Google Groups 
> "Racket Users" group.
> To unsubscribe from this group and stop receiving emails from it, send an 
> email to racket-users+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Struct properties and recursion

[jackhfirth]

Following up on this for anyone interested; I made a small wrapper library (
rebellion/struct-descriptor 
) around 
make-struct-type. You may find it interesting if you've created lots of 
struct types that all had to implement the same methods and properties. The 
library does the following:

   - Defines a struct-descriptor? 
   

 
   data type that combines the values that would be returned by 
   make-struct-type or struct-type-info.
   - Specifies that descriptors may be *initialized* or *uninitialized*, 
   where only initialized descriptors contain a reference to the created 
   struct-type? object.
   - Provides a make-struct-type/descriptor 
   

 
   function that's like make-struct-type, but instead of accepting a list of 
   property implementations it accepts a *property maker function*. This 
   function takes the uninitialized descriptor as an argument and returns a 
   list of property implementations. The make-struct-type/descriptor function 
   returns an initialized descriptor. This makes it easier to abstract over 
   property implementations, as you can make reusable functions that accept 
   uninitialized descriptors as arguments and return property implementations. 
   Oh, and it also has keyword arguments with reasonable defaults so you don't 
   have to look up the docs for all eleven parameters to make-struct-type and 
   write the defaults for the first eight just because the list of immutable 
   positions comes ninth.

This is kind of like the make-struct-type-property API that rocketnia 
mentions:

Instead of defining your `make-list-type-writer` abstraction as a function, 
> you can define it as a structure type property. (I think 
> `prop:auto-custom-write` may be an example of this technique.).This 
> property would make use of multiple features of 
> `make-struct-type-property`: It would first obtain a list of reflective 
> information about the struct type (since that's one of the parameters 
> passed to its guard procedure), and then it would use one of its supers 
> entries to populate `prop:custom-write` based on that information. One part 
> of the reflective information is an accessor procedure, so the generated 
> `prop:custom-write` procedure can call that instead of having to refer to 
> `point-x` and `point-y`.
>
> I find it a little surprising how well this technique corresponds to the 
> needs of a program that's avoiding fixed points. The bundle of reflective 
> information only contains certain information `struct` defines, namely the 
> accessor and mutator procedures. If it contained the structure type 
> descriptor or the constructor, then it would be possible to attempt to 
> access a property value *before* it was done being computed, essentially 
> letting us run into the very kind of use-before-definition error that we'd 
> get if we were using fixed points.
>

I wanted to avoid defining struct types like prop:auto-custom-write (which 
I didn't know about, thanks rocketnia!) that are only used to derive 
implementations of other struct types. That seems to me like it needlessly 
pollutes the API surface of the data types I create, and one function that 
creates all the properties is easier for me to understand than the 
graph-like approach of properties derived from other properties. But it is 
reassuring to know that make-struct-type-property passes information about 
the struct to the guard in a way that's roughly the same as my initialized 
/ uninitialized struct descriptors.

Since then, I've used my struct descriptors to implement two things:

   - make-struct-equal+hash-property 
   
, 
   which implements prop:equal+hash for opaque structs in the same way as the 
   default implementation for #:transparent structs.
   - make-constructor-style-struct-write-property 
   , 
   which implements prop:custom-write using make-constructor-style-printer 
   


Unfortunately I can't implement generic interfaces because there is no 
non-macro interface to that. See 
https://github.com/racket/racket/issues/1647 for some more background on 
that.

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more 

Re: Types of languages Re: [racket-users] the list of languages made with racket [Hacker News]

[Stephen De Gabrielle]

On Fri, 1 Mar 2019 at 18:00, Matthias Felleisen 
wrote:

>
>
> > On Mar 1, 2019, at 12:05 PM, Stephen De Gabrielle <
> spdegabrie...@gmail.com> wrote:
> >
> > Hi Matthias,
> > (or anyone else who is available to answer :))
> >
> > I'm trying to get my head around the range of possible languages in
> Racket.
> >
> > You got me thinking how many languages seem to have embedded little
> languages.
> > I was wondering how they fit into your categories of languages?
> >
> > 3. The nature of languages ranges from
> > — stand-alone languages with ugly syntax (example: datalog)
> > — #lang stand-alone DSLs (config, scribble)
> >
> > Does '#lang video' fit in this group?
>
> Yes.
>
>
> >
> > — #lang language mixins (s-expr, 2d)
> >
> > Do regular #px""/#rx expressions fit in this category?
>
> I don’t understand how #px is similar to the s-expr or at-expr or 2d #lang
> mixins. I am referring to lines such as #lang at-exp scribble.

[...]
> p.s. In my mind, format and regexp-match (and similar functions) are
> interpreters for programs in DSLs that are written down as strings. That’s
> my opening slides for HtDL (from last year).


The example from Greg Hendershot, below, gave the impression they were like
at-exp and the #2dcond syntax extension seems to fit the same pattern as
#px , but I see what you mean about regex-match and format being
interpreters.
@pregexp{\d\.\d}  ; #px"\\d\\.\\d"  (from
https://www.greghendershott.com/2015/08/at-expressions.html )
(I do use that trick to make regexp more readable - at-exp is great)

leaving aside my confusion, my goal here is to a page to the racket website
that showcases an selection of languages made with Racket, that is better
than a search of things that define a #lang

*#lang stand-alone languages with non-s-exp syntax* (I'm inclined not to
include 'ugly syntax' on a PR for the racket website)

   - Algol 60
   - Datalog
   - Scratchy
   - ProfessorJ (deliberately included as ~30% of job ads in the UK specify
   Java)
   - Rash: The Reckless Racket Shell
   - Riposte

-

*#lang stand-alone DSLs (config?, scribble)*

(I don't know a 'config' lang apart from #lang info)


   - Scribble
   - Hackett 
   - Heresy 
   - Lindenmayer 
   - Parenlog 
   - Pie 
   - Video


*#lang language mixins (s-expr, 2d)*


   - #lang s-exp [module]
   - #lang 2d racket
   - #lang at-exp

*embedded DSLs with mostly coarse-grained interactions with Racket (redex)*

Redex (require redex)
[need to identify another example]


*embedded DSLs with fine-grained interaction with Racket *(the language of
class syntax; syntax-parse: the pattern and templated languages, which
interact via syn-pattern vars)


   - (require racket/class)
   - syntax-parse
   - syntax-case patterns and templates etc.
   -

string interpreters

   - regexp
   - format


Languages with other targets

   - Asi64
   - Pollen
   - Scribble (?)
   - Racket-script


Are these good categories?

Kind regards,

Stephen

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] [racket users] Struct property question

[Ben Greenman]

prop:procedure is indeed pre-defined:

https://docs.racket-lang.org/reference/procedures.html#(def._((lib._racket%2Fprivate%2Fbase..rkt)._prop~3aprocedure))


Here's one way to look at things:

- struct is a tool for making new datatypes

- #:property is a hook for adding a new "skill" to the new datatype

- prop:procedure is the "skill" of being able to accept arguments,
like a function

- (struct-field-index base) is one way of saying how instances of the
new datatype behave like functions --- the prop:procedure docs explain
the other possibilities

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] lexer-parser approach in Racket [was the list of languages made with racket [Hacker News]]

[Matthias Felleisen]

> On Mar 1, 2019, at 2:29 PM, Aidan Gauland  wrote:
> 
> On 2/03/19 3:27 AM, Matthias Felleisen wrote:
>>> On Mar 1, 2019, at 2:15 AM, Aidan Gauland 
>>>  wrote:
>>> 
>>> On 24/02/19 12:08 PM, Matthias Felleisen wrote:
>>> 
 2. The means of implementation in Racket are radically different from a 
 lexer-parser approach.
 
>>> Wait, does this mean that the Beautiful Racket book is leading me down the 
>>> wrong path?  I'm in the middle of the bf chapter 
>>> 
>>> , which (if I am understanding it correctly, is using a lexer and a parser.
>>> 
>> Please read this comment in context. This line is a response to a particular 
>> point raised in the Reddit link of the original post. On this Reddit thread, 
>> someone seems to confuse creating DSLs with writing new syntax for 
>> more-or-less standard semantic concepts. For such people, it matters to find 
>> a conventional Lex-Yacc (replace with modern words) tool chain plus perhaps 
>> some support for backend creation.
>> 
>> [snip]
>> 
> I apologise for missing the context; I did take a look at the thread, but I 
> still misunderstood your remark initially.  Thanks for the clarification.


My response wasn’t meant as a rebuke. I really just wanted to say “the one-line 
statement is oversimplifying and you really need to look at the Reddit thread 
to understand its implications.” — Matthias

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] lexer-parser approach in Racket [was the list of languages made with racket [Hacker News]]

[Aidan Gauland]

On 2/03/19 3:27 AM, Matthias Felleisen wrote:
>> On Mar 1, 2019, at 2:15 AM, Aidan Gauland  wrote:
>>
>> On 24/02/19 12:08 PM, Matthias Felleisen wrote:
>>> 2. The means of implementation in Racket are radically different from a 
>>> lexer-parser approach.
>> Wait, does this mean that the Beautiful Racket book is leading me down the 
>> wrong path?  I'm in the middle of the bf chapter 
>> , which (if I am understanding it 
>> correctly, is using a lexer and a parser.
> Please read this comment in context. This line is a response to a particular 
> point raised in the Reddit link of the original post. On this Reddit thread, 
> someone seems to confuse creating DSLs with writing new syntax for 
> more-or-less standard semantic concepts. For such people, it matters to find 
> a conventional Lex-Yacc (replace with modern words) tool chain plus perhaps 
> some support for backend creation.
>
> [snip]

I apologise for missing the context; I did take a look at the thread,
but I still misunderstood your remark initially.  Thanks for the
clarification.

Regards,
Aidan Gauland

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: Types of languages Re: [racket-users] the list of languages made with racket [Hacker News]

[Matthias Felleisen]

> On Mar 1, 2019, at 12:05 PM, Stephen De Gabrielle  
> wrote:
> 
> Hi Matthias,
> (or anyone else who is available to answer :))
> 
> I'm trying to get my head around the range of possible languages in Racket.
> 
> You got me thinking how many languages seem to have embedded little 
> languages. 
> I was wondering how they fit into your categories of languages?
> 
> 3. The nature of languages ranges from 
> — stand-alone languages with ugly syntax (example: datalog)
> — #lang stand-alone DSLs (config, scribble)
> 
> Does '#lang video' fit in this group?

Yes. 


> 
> — #lang language mixins (s-expr, 2d)
> 
> Do regular #px""/#rx expressions fit in this category?

I don’t understand how #px is similar to the s-expr or at-expr or 2d #lang 
mixins. I am referring to lines such as #lang at-exp scribble. 


> 
> — embedded DSLs with mostly coarse-grained interactions with Racket 
> (redex)
> 
> would racket/class fit in this group?

I classified it with the next bullet. 

> would (require sql) fit in this group?

I think so. I haven’t used it. 


> — embedded DSLs with fine-grained interaction with Racket (the 
> language of class syntax; syntax-parse: the pattern and templated languages, 
> which interact via syn-pattern vars)
> 
> Do regular #px""/#rx expressions fit in this category?

I still don’t understand what you mean here. 

— Matthias


p.s. In my mind, format and regexp-match (and similar functions) are 
interpreters for programs in DSLs that are written down as strings. That’s my 
opening slides for HtDL (from last year). 

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[racket-users] apologies for duplicates

[George Neuner]

Something weird going on with my mail.  It appears an unfinished draft 
message replying to Curtis Dutton was sent several times over the course 
of about 10 minutes.  I don't know how this happened, but I apologize 
for accidentally spamming everyone.


George

--
You received this message because you are subscribed to the Google Groups "Racket 
Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[racket-users] Re: [racket-dev] Racket Realtime

[George Neuner]

Doh!  Hit send before I was done.


On 3/1/2019 11:50 AM, Curtis Dutton wrote:


Now I find myself wondering, why can't racket run in realtime? The GC 
is the most obvious hurdle that I can see. But racket execution speed 
by itself is plenty fast enough.


There are a number of reasons:  Racket's virtual machine model, the GC, 
the fact that Racket (currently) does not compile AOT to native code, 
but rather JITs at runtime, the fact that Racket does not allow hardware 
access, etc.  The TL,DR is that Racket wasn't ever designed with 
realtime execution in mind.


Most of these are not fixable without a complete rewrite. Racket-on-Chez 
changes the virtual machine model, and addresses the AOT compile issues, 
but the others remain.



So what I'm looking for is a racket language that doesn't generate 
garbage at execution time. But a "setup" phase could do so and it 
wouldn't be a problem.


You could create a variant that ignored garbage - like Javacard - but 
creating a Lisp/Scheme variant that didn't *create* garbage in the first 
place is a lot harder.  Such a language would have to give up 1st class 
closures.  Do you remember using Pascal's function parameters?


A realtime quality GC is an enormous project.  It might be easier to 
replace the GC with region based memory management.  Regions aren't 
completely immune to garbage, and a long running application does need 
GC as a fallback - but the GC in a mostly region system can be very low 
priority.



Is there such a thing? Is it worth pursuing? Or better to just stick 
with C?


You could look at Pre-Scheme, or PicoLisp, or Yalo.  But any Lisp/Scheme 
that is suitable will have significant limitations.  For hints at what 
you'd be giving up, look at the restrictions on "realtime" Java.


George

--
You received this message because you are subscribed to the Google Groups "Racket 
Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[racket-users] [racket users] Struct property question

[Kevin Forchione]

Hi guys, 
I’m trying to understand an example from the Racket manuals. 

(struct mood-procedure (base rating)
  #:property prop:procedure (struct-field-index base))

(define happy+ (mood-procedure add1 10))
 
(happy+ 2) <= 3

How does this work? It appears that prop:procedure is predefined. It appears 
that prop:procedure is assigned the value of whatever is assigned to the base 
slot of the struct, in this case add1. But although mood-procedure is a struct, 
happy+ appears to be a procedure! If I make mood-procedure transparent then 
happy+ looks like this:

(add1 # 10)

I’m not sure how the #:property kw made this transformation, nor what it means 
in terms of the uses of #:property. Any insight is appreciated.

Kevin

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Types of languages Re: [racket-users] the list of languages made with racket [Hacker News]

[Stephen De Gabrielle]

Hi Matthias,
(or anyone else who is available to answer :))

I'm trying to get my head around the range of possible languages in Racket.

You got me thinking how many languages seem to have embedded little
languages.
I was wondering how they fit into your categories of languages?

3. The nature of languages ranges from
> — stand-alone languages with ugly syntax (example: datalog)
> — #lang stand-alone DSLs (config, scribble)
>

Does '#lang

 video' fit in this group?

— #lang language mixins (s-expr, 2d)
>

Do regular #px""/#rx expressions fit in this category?

— embedded DSLs with mostly coarse-grained interactions with Racket
> (redex)
>

would racket/class fit in this group?
would (require

 sql ) fit in this group?

— embedded DSLs with fine-grained interaction with Racket (the
> language of class syntax; syntax-parse: the pattern and templated
> languages, which interact via syn-pattern vars)
>

Do regular #px""/#rx expressions fit in this category?


> All of these are available via libraries. And I am almost sure I
> am forgetting some classes of languages here.


Kind regards,

Stephen

PS I need to add minipascal to
https://github.com/racket/racket-lang-org/pull/89


On Sat, Feb 23, 2019 at 11:08 PM Matthias Felleisen 
wrote:

>
>
> The ycombinator post shows so many misunderstandings of the basic issue,
> it’s seriously sad. Here are some:
>
> 1. S-expression syntax does not mean it’s the same semantics.
> 2. The means of implementation in Racket are radically different from a
> lexer-parser approach.
> 3. The nature of languages ranges from
> — stand-alone languages with ugly syntax (example: datalog)
> — #lang stand-alone DSLs (config, scribble)
> — #lang language mixins (s-expr, 2d)
> — embedded DSLs with mostly coarse-grained interactions with
> Racket (redex)
> — embedded DSLs with fine-grained interaction with Racket (the
> language of class syntax; syntax-parse: the pattern and templated
> languages, which interact via syn-pattern vars)
> All of these are available via libraries. And I am almost sure I
> am forgetting some classes of languages here.
>
> I suspect that if we collected the languages in just these categories,
> we’d easily find over a hundred if not several hundred in both our code
> base as well as external code repos.
>
> Thanks for taking up the battle against this lack of knowledge out there —
> Matthias
>
>
>
>
>
>

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Re: the list of languages made with racket [Hacker News]

[Stephen De Gabrielle]

Hi Jérôme,

On Mon, Feb 25, 2019 at 2:19 PM Jérôme Martin 
wrote:

> I'm currently working on different open source projects, and every one of
> them features at least one or more #lang languages.
> Some use s-expressions, some have their own syntax using the "brag" parser
> generator.
>

Awesome!


> The thing is, most of them don't show up in the results because I didn't
> submitted them as Racket packages (I usually do that only with libraries)
> or because there are no scribble docs written yet.
> But I'm planning to make even more languages. Thanks to Racket, Language
> Oriented Programming has become my tool of the trade for pretty much
> everything.
>
> I guess I'll take some time to package some of them as standalone packages
> so that they can show up there, but it's not my priority.
>

I'd suggest following the instructions in Tutorial: Creating a Package
 by
Stephen Chang (
https://blog.racket-lang.org/2017/10/tutorial-creating-a-package.html)


> Do you folks think we should do some guide about "How to contribute
> languages to the Racket ecosystem" which would go through all the nuts and
> bolts of making a package "language-friendly" ?
> Something along the lines of "Hey, you have a project using Racket on
> Github, but you want it to show up in the Racket docs search? Here are the
> steps to register your package. You have languages inside? Don't forget to
> add this and that..."
>

I'd suggest
A) including scribble file
If you use `raco pkg new my-new-lang` it will also create a scribble file
that you can just treat as a text file without worrying about formatting
till you are ready.
B) tagging as both 'lang' and 'language' on the racket package catalog at
https://pkgs.racket-lang.org/
Create an account, add your package with the language and lang

Stephen

I know there already a lot of good documentation about that for people who
> know what they want. But I feel it's more about getting Racket developers
> aware that they can show up there in the first place (myself included, I
> just realized most of my projects don't show up there).
>

Adding your package to the racket packet repository is absolutely essential!

The How-to-get-started page on the GitHub wiki (at
https://github.com/racket/racket/wiki/How-to-get-started) has a set of
additional 'Getting started' links.


> It could also be a small blog post showing up the good parts of the doc...
> Or both. What do you think? (in fact, i'm definitely gonna write that blog
> post anyways)
>
> maybe update https://github.com/racket/racket/wiki/How-to-get-started, or
better still a Pull Request for the 'getting-started'
 documentation:Source
at
https://github.com/racket/racket/blob/master/pkgs/racket-doc/scribblings/getting-started/getting-started.scrbl


PS: scribble seems tricksy but you really can just dump plain text and it
will work fine. Or you can do cool stuff e.g.
https://gist.github.com/florence/b3fcc1df922008604e64362484dc1c28

OT: http://racket-news.com/2019/03/racket-news-issue-3.html

Kind regards,

Stephen



> --
> You received this message because you are subscribed to the Google Groups
> "Racket Users" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to racket-users+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] how to use union types

[Matthias Felleisen]

. . . all of which suggests that perhaps we should support blazingly fast list 
chaperones eventually :) 

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[racket-users] Racket News - Issue 3

['Paulo Matos' via Racket Users]

I have just published Issue 3 at

http://racket-news.com/2019/03/racket-news-issue-3.html

Grab a coffee and enjoy!

-- 
Paulo Matos

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.