Categorizing types of things in Janet? (plus cfunctions and abstract types)

[uvtc]

What are the types of things in Janet called? As in, you have simple objects like 1, 5.2, true, :this-and-that, and symbols, but also compound objects like @[1 2]. Maybe the latter are just referred to as "data structures"? But what are the former called?

In chat it was pointed out to me that there's an idempotent? function that seems to suggest maybe the term "atomic" for these simple objects?

It was also pointed out to me by @sogaiu that the types of things in Janet are listed right at https://github.com/janet-lang/janet/blob/master/src/include/janet.h#L399-L416.

The discussion began getting deeper, touching on function?, cfunction?, and abstract types.

Are cfunctions functions in Janet that are implemented in C? Which ones are these?

What are abstract types in Janet?

[sogaiu]

Here are some possibly relevant bits:

• C functions
• Abstract types

As to whether something is a cfunction, I think one may be able to use cfunction? to tell.

Also, the doc macro can provide some of that info. For example:

repl:1:> (doc os/time)


    cfunction

    (os/time)

    Get the current time expressed as the number of seconds since January
    1, 1970, the Unix epoch. Returns a real number.


nil

[yumaikas]

A cfunction is a binding from Janet to a function implemented in C. Most interpreted languages have that sort of construct, it varies in if they expose that in the type system or not. JavaScript on Chrome used to indicate if a function was "native" or composed via JS

I can't speak for Janet abstract types in detail, but I saw a comment about them being similar to a Lua userdata.

As far as categories of types, I'd suggest that you could break types in Janet into values and containers. Values would be integers, books, and symbols. Containers would be more like tables, structs, arrays, tuples and buffers. A string is the hybrid between the two, containing bytes, but usually considered as a value, and immutable.
Functions I would also classify as values.

But, for now, bakpakin is the ultimate authority on this. I do like that every container type has a mutable and an immutable version. It provides a nice symmetry.

[MikeBeller]

I did notice that maybe there aren't clear 'categories' of types in Janet. For what it's worth: Common LISP has "ATOM' to distinguish between atomic and compound (list) data.

Perhaps there should be a function atom? which would be true for number, boolean, nil, symbol. But how should it work for int/u64 which is an abstract type? (Maybe if janet_abstract->next is null then atom? should return true?)

And on this same topic -- anyone notice that Janet's indexed? returns true for array/tuple/struct/table, but false for string and buffer? But I think the indexed combinators work on strings and buffer. (Note: it is true that indexed? matches its documentation.)

Mike

[bakpakin]

Yes, there are some fuzzy boundaries for combining different types, but the difference between arrays/tuples and strings/symbols/keywords/buffers is that the former are recursive types - they can contain other recursive types. The latter contain just sequences of numbers.

Perhaps different predicates could make this clearer.

[uvtc]

I see that idempotent? (thanks, @ahungry ) returns true for both os/time (a cfunction) and for my own foo function:

(defn foo [x] (* x x))
(idempotent? os/time) #=> true
(idempotent? foo)     #=> true
(idempotent? 1)       #=> true
(idempotent? :hey)    #=> true
(idempotent? 'foo)    #=> true

I'd always thought of "idempotent" to mean a "pure" (side-effect free) function.

[pepe]

To clarify, what is the side-effect of the os/time? I see it as idempotent.

[uvtc]

Sorry for any confusion. That was just my own understanding of what the term means.

#!/usr/bin/env janet

(var x 2)

(defn foo
  []
  (print "side-effecting!")
  (set x 3))

(print x)
(foo) # 2
(print (idempotent? foo)) #=> true
(print x) # 3

[bakpakin]

idemptotent? is meant to mean "if this were compiled as the body of the function, would that function be idempotent?" This is a useful property for writing macros, and as long as we are conservative lets us not create extra bindings for things that are constant.

You can see how idempotent? is used in boot.janet for some macros.

[uvtc]

What specifically do you mean by, "..., and as long as we are conservative lets us not create extra bindings for things that are constant"?

[uvtc]

Ok, I think then the terms I was looking for were recursive (tuples, arrays, structs, tables) vs non-recursive (possibly aka "atomic") (symbols, keywords, strings, buffers, edit: booleans too).

And it's interesting to see the other categorizations:

• function vs cfunction
• Janet type vs abstract type
• indexed? vs dictionary? vs bytes?
• mutable vs immutable

[sogaiu]

Note that according to:

janet/src/include/janet.h

Lines 398 to 416 in 2abb87e

	/* Basic types for all Janet Values */
	typedef enum JanetType {
	JANET_NUMBER,
	JANET_NIL,
	JANET_BOOLEAN,
	JANET_FIBER,
	JANET_STRING,
	JANET_SYMBOL,
	JANET_KEYWORD,
	JANET_ARRAY,
	JANET_TUPLE,
	JANET_TABLE,
	JANET_STRUCT,
	JANET_BUFFER,
	JANET_FUNCTION,
	JANET_CFUNCTION,
	JANET_ABSTRACT,
	JANET_POINTER
	} JanetType;

JANET_ABSTRACT is a member(?) of JanetType.