The document shows the step-by-step transformation of the Clojure map function definition into an equivalent definition in the Slang programming language. It starts with the Clojure definition and iteratively modifies it through a series of small changes until arriving at the final Slang definition. The key steps are realizing that the list.empty? check is redundant, and replacing Clojure-specific terms like construct-seq and map with more general terms like applies and action.

1. Magne Matre Gåsland - Oslo, Norway, 2022-02-17
Clojure to Slang

2. Clojure:

3. (println (take 25 (map (* % %) (range))))

4. (defn squared [x] (* x x))
(println (take 25 (map (* % %) (range))))

5. (defn squared [x] (* x x))
(println (take 25 (map squared (range))))

6. (println (take 25 (map squared (range))))

7. (println (take 25 (map squared range)))

8. (println (take 25 range.map(squared)))

9. (println range.map(squared).take(25))

10. range.map(squared).take(25).println

11. Slang.

13. Clojure:

15. (defn map [function list]
(lazy-seq
(if (empty? list)
()
(let [[first & rest] list]
(construct-seq (function first)
(map function rest))))))

16. (defn map [function list]
(lazy-seq
(if (empty? list)
()
(let [[first & rest] list]
(construct-seq (function first)
rest.map(function))))))

17. (defn map [function list]
(lazy-seq
(if (empty? list)
()
(let [[first & rest] list]
(construct-seq first.function
rest.map(function))))))

18. (defn map [function list]
(lazy-seq
(if list.empty?
()
(let [[first & rest] list]
(construct-seq first.function
rest.map(function))))))

19. (defn map [function list]
(lazy-seq
(if list.empty?
()
(let [[first & rest] list]
first.function.construct-seq(
rest.map(function))))))

20. [function list].defn(map
(lazy-seq
(if list.empty?
()
(let [[first & rest] list]
first.function.construct-seq(
rest.map(function))))))

21. [function list].map =
(lazy-seq
(if list.empty?
()
(let [[first & rest] list]
first.function.construct-seq(
rest.map(function)))))

22. list.map(function) =
(lazy-seq
(if list.empty?
()
(let [[first & rest] list]
first.function.construct-seq(
rest.map(function)))))

23. list.map(function) =
(lazy-seq
(if list.empty?
()
(let [[first & rest] list]
first.function.construct-seq(
rest.map(function)))))

24. list.map(function) =
(lazy-seq
(if list.empty?
()
(let [[first & rest] list]
first.function.construct-seq(
rest.map(function)))))

25. list.map(function) =
(if list.empty?
()
(let [[first & rest] list]
first.function.construct-seq(
rest.map(function)))).lazy-seq

26. list.map(function) =
list.empty?(
()
(let [[first & rest] list]
first.function.construct-seq(
rest.map(function)))).lazy-seq

27. list.map(function) =
list.empty?(
()
(let [[first & rest] list]
first.function.construct-seq(
rest.map(function)))
).lazy-seq

28. list.map(function) =
list.empty?(
()
(let [[first & rest] list]
first.function.construct-seq(
rest.map(function)
)
)
).lazy-seq

29. list.map(function) =
list.empty?(
()
[first & rest] = list
first.function.construct-seq(
rest.map(function)
)
).lazy-seq

30. list.map(function) =
list.empty?(
()
[first & rest] = list
first.function.construct-seq(rest.map(function))
).lazy-seq

31. list.map(function) =
list.empty?(
()
[first & rest] = list
first.function + rest.map(function)
).lazy-seq

32. list.map(function) =
list.empty?(
()
[first & rest] = list
list.first.function + list.rest.map(function)
).lazy-seq

33. list.map(function) =
list.empty?(
()
list.first.function + list.rest.map(function)
).lazy-seq

34. list.map(function) =
list.empty?(
()
list.first.function + list.rest.map(function)
).lazy-seq

35. list.map(function) =
list.empty?(
()
list.first.function + list.rest.map(function)
).lazy-seq

36. list.map(function) =
list.empty?(
()
list.first.function + list.rest.map(function)
).lazy-seq

37. // if list is empty then it should return ()
// Consider:
list.map(function) =
list.empty?(
()
list.first.function + list.rest.map(function)
).lazy-seq

38. // if list is empty then it should return ()
// Consider:
list.map(function) =
list.empty?(
()
().first.function + ().rest.map(function)
).lazy-seq

39. // ().first should return ()
// Consider:
list.map(function) =
list.empty?(
()
().first.function + ().rest.map(function)
).lazy-seq

40. // Consider:
list.map(function) =
list.empty?(
()
().function + ().rest.map(function)
).lazy-seq
// ().first should return ()

41. // ().rest should return ()
// Consider:
list.map(function) =
list.empty?(
()
().function + ().rest.map(function)
).lazy-seq

42. // Consider:
list.map(function) =
list.empty?(
()
().function + ().map(function)
).lazy-seq
// ().rest should return ()

43. // ().function should return ()
// Consider:
list.map(function) =
list.empty?(
()
().function + ().map(function)
).lazy-seq

44. // ().function should return ()
// Consider:
list.map(function) =
list.empty?(
()
() + ().map(function)
).lazy-seq

45. // ().map(function) should return ()
// Consider:
list.map(function) =
list.empty?(
()
() + ().map(function)
).lazy-seq

46. // Consider:
list.map(function) =
list.empty?(
()
() + ()
).lazy-seq
// ().map(function) should return ()

47. // () + () should return ()
// Consider:
list.map(function) =
list.empty?(
()
() + ()
).lazy-seq

48. // Consider:
list.map(function) =
list.empty?(
()
()
).lazy-seq
// () + () should return ()

49. // Consider:
list.map(function) =
list.empty?(
()
()
).lazy-seq

50. // Consider:
list.map(function) =
list.empty?(
()
()
).lazy-seq

51. // Consider:
// So, given that the aforementioned functions
// work that way,
list.map(function) =
list.empty?(
()
()
).lazy-seq

52. // So, given that the aforementioned functions
// work that way, the list.empty? check is redundant.
// Consider:
list.map(function) =
list.empty?(
()
()
).lazy-seq

53. // So, given that the aforementioned functions
// work that way, the list.empty? check is redundant.
// It would return the same result either way.
// Consider:
list.map(function) =
list.empty?(
()
()
).lazy-seq

54. // Consider:
list.map(function) =
list.empty?(
()
()
).lazy-seq

55. // Lets go back to where we started our consideration:
list.map(function) =
list.empty?(
()
()
).lazy-seq

56. // Lets go back to where we started our consideration:
list.map(function) =
list.empty?(
()
list.first.function + list.rest.map(function)
).lazy-seq

57. // Since list.empty? is redundant, we have:
list.map(function) =
list.empty?(
()
list.first.function + list.rest.map(function)
).lazy-seq

58. // Since list.empty? is redundant, we have:
list.map(function) =
(
list.first.function + list.rest.map(function)
).lazy-seq

59. list.map(function) =
(
list.first.function + list.rest.map(function)
).lazy-seq

60. list.map(function) =
(list.first.function + list.rest.map(function)).lazy-seq

61. list.map(function) = (list.first.function + list.rest.map(function)).lazy-seq

62. list.map(function) = (list.first.function + list.rest.map(function)).lazy-seq

63. list.map(function) = (list.first.function + list.rest.map(function)).lazy-seq

64. list.map(function) = (
list.first.function + list.rest.map(function)
).lazy-seq

65. list.map(function) = (
list.first.function + list.rest.map(function)
).lazy-seq
// Compare with original…

66. // Compare with original…
list.map(function) = (
list.first.function + list.rest.map(function)
).lazy-seq

67. // Compare with original…
list.map(function) = (
list.first.function + list.rest.map(function)
).lazy-seq
(defn map [function list]
(lazy-seq
(if (empty? list)
()
(let [[first & rest] list]
(construct-seq (function first)
(map function rest))))))

68. list.map(function) = (
list.first.function + list.rest.map(function)
).lazy-seq

69. list.map(function) = (
list.first.function + list.rest.map(function)
).lazy-seq

70. list.applies(function) = (
list.first.function + list.rest.applies(function)
).lazy-seq

71. list.applies(action) = (
list.first.action + list.rest.applies(action)
).lazy-seq

72. list.applies(action) = (
list.first.action + list.rest.applies(action)
).lazily

73. Slang.