Sugar Free Syntax

Question

In Haskell the list notation:

[a,b,c]

Is just syntactic sugar for:

a:b:c:[]

And the string notation:

"abc"

Is just syntactic sugar for:

['a','b','c']

This means that the string:

"abc"

Is the same as:

'a':'b':'c':[]

Task

Given a string you should output what the de-syntaxed version would look like in Haskell.

Rules

• You will receive a string by any valid input method, you should output a string ending with :[] with every character from the input surrounded by ' and separated by :. The empty string should output [].

• You can assume that you will not receive any characters that require escaping (e.g. ', newlines, tabs ...) and that input will be in the printable ascii range

• This is code-golf you should aim to minimize the byte count of your answer

Test Cases

"" -> []
"a" -> 'a':[]
"Hello, World" -> 'H':'e':'l':'l':'o':',':' ':'W':'o':'r':'l':'d':[]   

Answer 1

Haskell, 26 bytes

(++"[]").((++":").show=<<)

Try it online!

Explanation:

In non-pointfree notation and using concatMap instead of =<<, this becomes

f s = concatMap(\c-> show c ++ ":")s ++ "[]"

Given a string s, we map each char c to a string "'c':" using the show function which returns a string representation of most Haskell types. Those strings are concatenated and a final [] is appended.

Although not requested by the challenge, this answer even works with proper escaping, because show takes care of it: f "'" yields "'\\'':[]".

Answer 2

Haskell, 33 28 26 bytes

foldr((.(':':)).shows)"[]"

Try it online!

fold the given pointfree function from the right into the input string starting with []. The function is: show char as a Haskell char, i.e. surrounded with ' and concatenate with the result so far after putting a : in front of it.

Edit: @Ørjan Johansen saved two bytes. Thanks!

Answer 3

Python 3, 32 bytes

lambda s:"%r:"*len(s)%(*s,)+"[]"

Try it online!

Answer 4

JavaScript ES6, 42 40 31 bytes

s=>s.replace(/./g,"'$&':")+"[]"

Replaces each char with '<char>':, then adds [] to the end

Try it online!

Answer 5

Common Lisp, 50 42 bytes

(format t"~{'~a':~}[]"(coerce(read)'list))

Try it online!

Reduced thanks to the comment of @coredump, by using read instead of defining a function.

Answer 6

V, 11 bytes

Í./'&':
A[]

Try it online!

Uses a regex to surround every input character with '': and then Appends [] to the end.

Answer 7

C, 55 54 53 bytes

s(char*h){while(*h)printf("'%c':",*h++);puts("[]");}

Answer 8

05AB1E, 15 12 11 10 bytes

-3 bytes thanks to carusocomputing
-1 byte thanks to Adnan
-1 byte thanks to Erik the Outgolfer's genius idea

ʒ"'ÿ':"?},

Try it online!

ʒ          # Filter out every character that the following code doesn't return 1 for
 "'ÿ':"?   #   Print the string 'ÿ': with ÿ replaced by this character
        }  # End for
         , # No character returned 1 so an empty array is left on the stack. Print that

Answer 9

Pyth, 14 10 8 bytes

j\:a`MQY

Try this!

-2 bytes thanks to @isaacg

Finally, pyth is good at something.

explanation

j\:a`MQY
    `MQ        # map the representation over the input string: ["'a'","'b'",...]
   a   Y       # append the empty list
j\:            # join on :

Answer 10

Python 3, 41 38 36 bytes

^{-2 bytes thanks to ovs}

print(*map(repr,input()),[],sep=':')

Try it online!

Answer 11

R, 51 bytes

f<-function(x)(paste0(gsub("(.)","'\\1':",x),'[]'))

Answer 12

Retina, 12

• 3 bytes saved thanks to @FryAmTheEggman

.
'$&':
$
[]

2 stages:

• for each remaining character put ' ': around it
• add [] to the end

Try it online.

Answer 13

Perl 6, 19 bytes

{S:g|.|'$/':|~'[]'}

Answer 14

Python 2, 48 46 44 37 bytes

-2 bytes thanks to Rod. -7 bytes thanks to Wheat Wizard.

lambda s:':'.join(map(repr,s)+['[]'])

Try it online!

Answer 15

JavaScript (ES6), 36 bytes

s=>s?`'${[...s].join`':'`}':[]`:"[]"

---

Try it

f=
s=>s?`'${[...s].join`':'`}':[]`:"[]"
oninput=_=>o.innerText=f(i.value);o.innerText=f(i.value="abc")

<input id=i><pre id=o>

Answer 16

Befunge, 29 27 bytes

<,,,,\_v#`0:~"'':"
@,,"[]"<

Try it online!

Answer 17

Jelly,  11 10  8 bytes

-1 byte thanks to Christian (remove concatenation ; and utilise implicit printing instead)

+0 bytes (fixed for edge case of an empty string - previously the full program: ŒṘ€j”:“:[])

-2 thanks to Erik the Outgolfer (use p in place of ;€ since ”: is effectively length 1; use Ø[ since it has become shorthand for ⁾[])

ŒṘ€p”:Ø[

Try it online!

A full program printing the result (as a link it returns a list of lists of characters).

...but is there a way to save using STDIN?

How?

ŒṘ€p”:Ø[ - Main link: list of characters, s  e.g. "Hey"
ŒṘ€      - Python representation for €ach    [["'",'H',"'"],["'",'e',"'"],["'",'y',"'"]]
    ”:   - literal character = ':'
   p     - Cartesian product                 [["'",'H',"'",':'],["'",'e',"'",':'],["'",'y',"'",':']]
         - implicit print (no newline): 'H':'e':'y':
      Ø[ - literal list of characters        ['[',']']
         - implicit print (no newline): []

Answer 18

PHP, 41 bytes

<?=preg_filter("#.#","'$0':",$argn)."[]";

Try it online!

Answer 19

Perl 5, 22 bytes

19 bytes of code + -p flag.

s/./'$&':/g;$\="[]"

Or, for the same bytecount, s/./'$&':/g;s/$/[]/.

Quite straight forward: s/./'$&':/g surrounds each characters with quotes and add a : after. $\ is implicitly printed after each print, so setting it to [] outputs the final [].

Try it online!

Answer 20

brainfuck, 68 bytes

+[-->+[<]>-]>>,[<.>.<.>>-[>+<+++++++++]>+.[-]<<,]-[+[+<]>>+]<+++.++.

Try it online!

Answer 21

Java (OpenJDK 8), 86 83 76 bytes

-3 bytes thanks to @KevinCruijssen
-7 bytes thanks to @FlorianSchaetz

s->{String b="";for(char c:s.toCharArray()){b+="'"+c+"':";};return b+"[]";};

Try it online!

Answer 22

Brain-Flak, 135, 131 bytes

{({}<>)<>}(((((((()()()()()){})){}{}())){}{})[()()])<>{<>(((((((()()()){}()){}){}()){})[(((()()()){})){}{}()])<>)({}<({}<>)>)<>}<>

Try it online!

+1 byte for the -c flag.

Thanks to WheatWizard for removing very obvious NOOPs that I had for no reason XD.

Answer 23

Cubix, 31 29 bytes

uo@[)o'U);!A?ro;o;o;os:'/u:''

A can also be substituted for i; trying to figure out if there's a good way to squeeze another byte or two out of this. -2 bytes thanks to MickyT! Also outgolfed by MickyT!

Fits on a 3x3x3 cube:

      u o @
      [ ) o
      ' U )
; ! A ? r o ; o ; o ; o
s : ' / u : ' ' . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Watch it online!

Try it online!

Answer 24

Standard ML, 52 50 bytes

Saved 2 bytes thanks to @Laikoni!

fn s=>String.translate(fn c=>"'"^str c^"':")s^"[]"

Try it online!

String.translate is an unfortunately long name, but was 5 bytes shorter than using concat, map, and explode.

Answer 25

Python 2, 47 bytes

lambda a:`list(a)+[[]]`.replace(', ',':')[1:-1]

Try it online!

Answer 26

APL (Dyalog), 21 19 bytes

'[]',⍨'.'⎕R'''&'':'

Try it online!

'[]',⍨ the brackets appended to

'.' every character

⎕R PCRE Replaced with

'''&'':' a quote, the match, a quote and a colon

Answer 27

Japt, 14 13 bytes

A port of Downgoat's JS solution.

ç"'$&':" +"[]

Try it

Answer 28

sed, 19 18 bytes

-1 byte thanks to Jordan

s/./'&':/g;s/$/[]/

Try it online!

Answer 29

R, 75 50 bytes

function(x)cat(gsub("(.)","'\\1':",x),"[]",sep="")

Try it online!

Or for a non-regex approach:

R, 63 bytes

function(x)cat(sprintf("'%s':",el(strsplit(x,''))),'[]',sep='')

Try it online!

It turns out that sprintf will recycle the format string to match the length of its input, which is a nice golf from the previous answer (which you can see in the edit history).

Answer 30

JavaScript 23 40 bytes

f=s=>!s?"[]":"'"+[...s].join("':'")+"':[]"

f=s=>!s?"[]":"'"+[...s].join("':'")+"':[]"
console.log(f() + "\n") // `"[]"`
console.log(f("") + "\n") // `"[]"`
console.log(f("abc") + "\n") // "'a':'b':'c':[]"

Using spread element to convert string to array, Array.prototype.join() to concatenate ":" characters

Answer 31

PHP, 39 bytes

<?while(~$c=$argn[$i++])echo"'$c':"?>[]

Run as pipe with -F.

Answer 32

Convex, 10 bytes

{`':`}%"[]

Try it online!

Answer 33

Cubix, 27 bytes

uosW?U.iv":'"^soso;os@o[]'/

Try it online!

      u o s
      W ? U
      . i v
" : ' " ^ s o s o ; o s
@ o [ ] ' / . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Watch it run

A slightly different variation from Guiseppe's answer. This puts the colon and quote on the stack. Then it loops through the input, swapping and outputting the stack. Only the input is scrapped and the colon and quote are retained.

Once the end of the input is reached the IP wonders around the cube a bit, adding and outputting the brackets. There are a couple of redundant commands in the mix.

Answer 34

Ruby, 43 bytes

->a{a==''?'[]':"'#{a.chars.join"':'"}':[]"}

Answer 35

Excel, 68 bytes

=IFERROR(CONCAT("'"&MID(A1,ROW(OFFSET(A1,,,LEN(A1))),1)&"':"),)&"[]"

Takes input from A1, outputs to whatever cell this formula is placed in. It's an array formula, so Ctrl-Shift-Enter instead of Enter to enter it.

11 of the bytes here are just for handling the empty string correctly, since Excel doesn't have a concept of arrays with zero elements.

The answer's pretty straightforward, but I did learn a couple things: IFERROR's second argument is taken to be "" when left blank, and & will operate in an array-aware manner if and only if the construction is inside a function that will take an array (replacing CONCAT(...) with just (...) feels like it should work but it doesn't).

Answer 36

SOGL, 12 bytes

,{ļ'pō':}ō[]

Explanation:

,{      }     iterate over the chars of string input
  ļ'          output "'"
    p         output the current char
     ō':      output "':"
         ō[]  output "[]"

In theory 10 byte ļ'pō':}ō[] could work, but, alas, it doesn't.

Answer 37

Ruby, 43 28 + 1 = 44 29 bytes

A whopping -15 bytes thanks to Value Ink.

+1 byte for the -p flag.

$_=gsub(/(.)/,"'\\1':")+"[]"

Try it online!

Answer 38

Aceto, 26 bytes

:Lpp&p
'p|L
\'!d["
'M@,]"p

Answer 39

PowerShell, 43 bytes

It's a join(map(repr, input)) shape problem? That's simply 177 bytes of:

[linq.enumerable]::Aggregate([Linq.Enumerable]::Select(
[Object[]][Char[]]"$args", [Func[Object,String]]{"'$args'"})+(,'[]'),
[func[object,object,object]]{param($a,$b) $a+':'+$b})

Edit: can golf that down to a mere 171:

$e='[Linq.Enumerable]::';$o='Object';
"${e}Aggregate(${e}Select([$o[]][Char[]]""$args"",[Func[$o,$O]]{""'`$args'""})+(,'[]'),[func[$o,$o,$o]]{`$args[0]+':'+`$args[1]})"|iex

Oh all right, 43 bytes of:

(([char[]]"$args"|%{"'$_'"})+,'[]')-join':'

Answer 40

Swift, 49 bytes

{$0.characters.reduce("",{$0+"'\($1)':"})+"[]"}

This is a lambda (closure in Swift). Because converting a Character Array to a string is a.joined(seperator:"") I've used .reduce("",+) as a golf. Kind of unreadable so broken down:

{
  $0.characters.reduce("", {
    $0 + "'\($1)':"
  }) + "[]"
}

because a map + converting to a string is too long, reduce will convert to a string for us as we go

Answer 41

><>, 27 bytes

i:0(?vd3*:o$oo':'o
o'[]'/;o

Try it online!

Answer 42

Noether, 37 bytes

{I~sL0>}{sL("'"Psi/P"':"Pi1+~i)}"[]"P

Try it here!

Takes input between quotation marks.

Answer 43

Excel VBA, 51 bytes

Anonymous VBE immedate function that takes input as string from cell [A1], iterates across the input string, splitting it by character and then outputs to the VBE immediate window

For i=1To[Len(A1)]:?"'"Mid([A1],i,1)"':";:Next:?"[]

Previous, Longer Versions

1:  a=Split(StrConv([A1],64),Chr(0)):For i=0To[Len(A1)-1]:?"'"a(i)"':";:Next:?"[]"

2:  ?"'"Mid(Join(Split(StrConv([A1],64),Chr(0)),"':'"),1,4*Len([A1])-1)"[]"

3:  ?"'"Left(Join(Split(StrConv([A1],64),Chr(0)),"':'"),4*Len([A1])-1)"[]"

4:  ?"'"Replace(Left(Strconv([A1],64),2*Len([A1])-1),Chr(0),"':'")":[]"    

5:  ?Replace(Left("'"&StrConv([A1],64),2*Len([A1])),Chr(0),"':'")"':[]"

6:  ?"'"Left(Replace(StrConv([A1],64),Chr(0),"':'"),4*Len([A1])-1)"[]"

7:  ?"'"Replace(Replace(StrConv([A1],64),Chr(0),"':'")&" ","' ","[]")

8:  For i=1To Len([A1]):?"'"&Mid([A1],i,1);"':";:Next:?"[]"

9:  For i=1To[Len(A1)]:?"'"&Mid([A1],i,1);"':";:Next:?"[]"

10: For i=1To[Len(A1)]:?"'"Mid([A1],i,1)"':";:Next:?"[]"

Answer 44

Mathematica, 34 bytes

"'"<>#<>"':"&/@Characters@#<>"[]"&

Anonymous function. Takes a string as input and returns a string as output. Just separates the input's characters, inserts '...': around each, and adds [] to the end.

Answer 45

Charcoal, 11 bytes

ＦＳ⁺⁺'ι':¦[]

Try it online! Explanation provided as AST.

Answer 46

Rust, 69 bytes

|s:&str|s.chars().map(|s|format!("'{}':",s)).collect::<String>()+"[]"

Couldn't find anything shorter than the trivial solution.

Answer 47

Java, 60 bytes

String f(String s){return s.replaceAll(".","['$0']:")+"[]";}

Answer 48

brainfuck, 48 bytes

-[-[<++>->++>-<<]>]<<,[<-.>.<.+<.>>,]<<<<+++.++.

Try it online!

Answer 49

Stax, 10 bytes

╩8┼Φv╚▀╛┴►

Run and debug it

Answer 50

MATL, 16 bytes

g39*Gyt19+v'[]'h

Try it online!

A bit surprised not to see a MATL submission already.

Explanation:

	% implicit input, 'abc'
g	% convert to logical
	% STACK: {[1 1 1]}
39*	% multiply by 39, ASCII for ', elementwise.
	% STACK: {[39 39 39]}
G	% push input
	% STACK: {[39 39 39]; 'abc'}
yt	% copy from below and dup
	% STACK: {[39 39 39]; 'abc'; [39 39 39]; [39 39 39]}
19+	% add 19, elementwise, to get 58, ASCII for :
	% STACK: {[39 39 39]; 'abc'; [39 39 39]; [58 58 58]}
v	% vertically concatenate stack contents, implicitly converting to strings.
	% STACK: {'''
	%	  abc
	%	  '''
	%	  :::}
'[]'h	% push '[]' and horizontally concatenate, linearizing as needed
	% STACK: 'a':'b':'c':[]
	% implicit output

Answer 51

Jelly, 13 bytes

”';Ѐ;€⁾':⁾[]

Try it online!

Explanation:

”';Ѐ;€⁾':⁾[]

”';Ѐ            Concatenate ' to the beginning of each element
     ;€⁾':       Concatenate ': to the end of each element
          ⁾[]    Implicit concatenation of literal "[]"

Answer 52

CJam, 13 12 bytes

q{`':`}%"[]"

Explanation:

q    e# Input: "test"
{    e# For each character: ['t 'e 's 't]
  `  e#   Get the string representation: ["'t" "'e" "'s" "'t"]
  ': e#   Push the character ':': ["'t" ': "'e" ': "'s" ': "'t" ':]
  `  e#   Get the string representation: ["'t" "':" "'e" "':" "'s" "':" "'t" ':]
}%   e# End
"[]" e# Push the string "[]"
e# Implicit print: 't':'e':'s':'t':[]

Answer 53

braingasm, 18 bytes

,[39.."':".,]"[]".

Just a simple loop, reading one byte at a time and printing the necessary stuff before and after the input, then the final square brackets.

Test run:

$ echo -n Hello | braingasm haskell_strings.bg 
'H':'e':'l':'l':'o':[]

Answer 54

QBIC, 35 bytes

[_l;||X=X+@'`+_sA,a,1|+B+@:`]?X+@[]

Explanation

[    |         FOR a = 1 TO
 _l |           the length of
   ;              input string
X=X+@'`        Add to Z$ a literal '
   +_sA,a,1|   and a 1-char substring at index a of the input A$
   +B          and another quote (defining it as literal created B$)
   +@:`        and a literal :
]              NEXT
?X+@[]         PRINT Z$ and a literal [] (no closing backtick because EOF)

Answer 55

Octave, 37 bytes

@(s)(s&&printf("'%c':",s))+puts("[]")

Try it online!

Answer 56

Braingolf, 29 bytes

VRl1-M[R>#'<"':">>>>v]R"[]"&@

Try it online!

Currently a bug in Braingolf foreach loops that breaks them when handling 2 adjacent duplicates (such as the ls in Hello), so I have to use this method that costs me an extra 13 bytes

If foreach loops worked properly, it would've been this, which is only 16 bytes:

{>#'<"':"}"[]"&@

Explanation

VRl1-M[R>#'<"':">>>>v]R"[]"&@  Implicit input from commandline args
VRl1-M                         Create stack2, push length of stack1 - 1 to stack2
      [..............]         Do-While loop, will run for each item on stack1
       R>                      Return to stack2, move ToS to bottom
         #'<                   Push single quote and move BoS back to top
            "':"               Push single quote and colon
                >>>>           Rotate stack to next item from input
                    v          Switch to stack2 for loop counting
                      R"[]"&@  Switch to stack1, push [] and print entire stack

Answer 57

Groovy, 37 bytes

{it.replaceAll(~/./,{"'$it':"})+"[]"}

(It's an anonymous closure, which can be called thus {...}("hello") or via a name thus f = {...};f("hello").)

Answer 58

Python 3, 36 bytes

lambda s:':'.join(map(repr,[*s,[]]))

A variation of Rod's one.

Try it online!

Answer 59

setlx, 36 bytes

s|->join(["'"+x+"':":x in s],"")+"[]";

Explanation:

s |->                               // a function taking an argument s
    join(                           // join:
        [ "'" + x + "':" : x in s], // a list from each char wrapped in quotes
        ""                          // with the empty string
    ) 
    + []                            // add an empty list to the string, this will convert it to the string "[]"
;

Answer 60

Clojure, 42 bytes

#(str(apply str(for[c %](str"'"c"':")))[])

Answer 61

Javascript 33 bytes

f=s=>s.replace(/(.)/g,"'$1':")+'[]'

Answer 62

><>, 25 bytes

i:0(?v":''"o{ooo
o"[]"<;o

Try it online!

Answer 63

Actually, 9 bytes

♂è[]@q':j

Try it online!

Explanation:

♂è[]@q':j
           implicit input ("abc")
♂è         push a list containing the string representation of each character (['a', 'b', 'c'])
  []@q     add an empty list to the end of that list (['a', 'b', 'c', [])
      ':j  join with colons ("'a':'b':'c':[]")
           implicit print ('a':'b':'c':[])

Answer 64

Pari/GP, 52 bytes

s->c=concat;c(c([Str("'",x,"':")|x<-Vec(s)],["[]"]))

Try it online!

Answer 65

SNOBOL4 (CSNOBOL4), 81 bytes

	N =INPUT
S	N LEN(1) . X REM . N	:F(O)
	O =O "'" X "':"	:(S)
O	OUTPUT =O "[]"
END

Try it online!

Answer 66

Add++, 30 bytes

D,f,@*,39@39 58
L^~,€{f}"[]"BF

Try it online!

How it works

D,f,@*,		; Create a function, 'f', that
		; that takes one argument, and returns the full stack
		; Example argument:	['a']
	39@	; Prepend 39;	STACK = [39 'a']
	39 58	; Push 39, 58;	STACK = [39 'a' 39 58]
		; Return the full stack
		; 39 is the ordinal of ' and 58 of :

L^~,		; Create a lambda function
		; The ^ converts all integers to characters, then concatenates, when returning
		; The ~ unpacks the argument beforehand
		; Example argument:		['a' 'b' 'c']
	€{f}	; Run 'f' over each;	STACK = [[39 'a' 39 58] [39 'b' 39 58] [39 'c' 39 58]]
	"[]"	; Push '[]';		STACK = [[39 'a' 39 58] [39 'b' 39 58] [39 'c' 39 58] '[]']
	BF	; Flatten;		STACK = [39 'a' 39 58 39 'b' 39 58 39 'c' 39 58 '[]']
		; The ^ flag converts integers to characters:
		;			STACK = ["'" 'a' "'" ':' "'" 'b' "'" ':' "'" 'c' "'" ':' '[]']
		; Then concatenates them into a single string:
		;			STACK = ["'a':'b':'c':[]"]
		; And returns the top value:
		;			Return "'a':'b':'c':[]"

Answer 67

SmileBASIC 3, 53 48 bytes

-5 with the WHILE trick, thanks 12Me21!

LINPUT S$WHILE""<S$?"'"+SHIFT(S$)+"':";
WEND?"[]

Explainer:

LINPUT S$              'Read line from console
WHILE ""<S$            'WHILE S$ is not empty
 ?"'"+SHIFT(S$)+"':";  'Print 'x': where x is popped off the front of S$
WEND                   'End WHILE
?"[]"                  'Print []

Answer 68

Husk, 9 bytes

J':`:søms

Try it online!

Explanation

J':`:søms  Implicit input                                 "abc"
       ms  String representation of each character        ["'a'","'b'","'c'"]
   `:sø    Append the string of an empty list to the end  ["'a'","'b'","'c'","[]"]
J':        Join with a colon character                    "'a':'b':'c':[]"

Answer 69

F#, 55 bytes

My first F#, which means it probably isn't very good. _{My SmileBASIC answer is beating it, even...}

fun s->List.reduce(+)[for c in s->sprintf"'%c':"c]+"[]"

Try it online. Golfing tips are appreciated

Answer 70

Kotlin, 34 bytes

{it.fold(""){a,v->a+"'$v':"}+"[]"}

Try it online!

Answer 71

Ahead, 25 bytes

v>"]["W@
>jri''r
^W"':"W<

Try it online!

Answer 72

Burlesque - 21 bytes

m{bx"'~':"jf~}"[]"_+Q

Longer versions:

XX{bx"'~':"jf~}\m"[]"_+Q

Burlesque shows characters with a single ' i.e. 'x instead of 'x' which is why we have to surround characters manually with two 's.

Answer 73

Forth (gforth), 47 bytes

: f bounds ?do ." '"i 1 type ." ':"loop ." []";

Try it online!

Code Explanation

: f          \ start a new word definition
  bounds     \ get the starting and ending addresses of the string
  ?do        \ loop from start to end (skip if start=end)       
    ." '"    \ output '
    i 1 type \ print the character at the current address
    emit     \ output character of string
    ." ':"   \ output ':
  loop       \ end loop
  ." []"     \ output []
;            \ end word definition