Preface
Goal: Finishing the task, using functional approach.
8: Approach in Solving Unique
A custom example, that you can rewrite.
An Algorithm Case
Why reinvent the wheel?
The same reason as any other articles.
x:xs Pattern Matching
The same with any other articles as well.
Remove Element from List
Guile has this built in delq.
(define tags (list
"rock" "jazz" "rock" "pop" "pop"))
(display (string-join (delq "rock" tags) ":"))
(newline)With the result as below list:
❯ guile 11-exclude-a.scm
jazz:pop:pop
Exclude Function
For practice purpose, we can bundle the code in it own subroutine.
(define tags (list
"rock" "jazz" "rock" "pop" "pop"))
(define
(delq-clone value tags)
(delq value tags)
)
(display (string-join
(delq-clone "rock" tags) ":"))
(newline)With the result exactly the same as previous code.
You don’t need this exclude function. It is just a demonstration of writing a function, along with its argument. We are going to understand the basic, before writing recursive unique function later.
9: Preparing Unique Function
I’l be kind. My reader might be a beginner. So I explain step by step.
Guard
There is no need to process unique list, for list with just one member, so we need to differ the process result using conditional, as shown in code below:
(use-modules (oop goops))
(define my-tags (list
"rock" "jazz" "rock" "pop" "pop"))
(define-method
(unique-guard (tags <list>))
(if
(<= (length tags) 1)
(tags)
(cdr tags)
))
(display (unique-guard my-tags))
(newline)With the result as below list:
❯ guile 12-unique-a.scm
(jazz rock pop pop)
Notice goops module required for further code subroutine signature.
Head and Tail
Our recursive function require this variable:
- Head and Tail
- Excluded list, based on head and tail above.
Preliminary code can be written as below:
(use-modules (oop goops))
(define my-tags (list
"rock" "jazz" "rock" "pop" "pop"))
(define-method
(unique-var (tags <list>))
(let
( (head (car tags)) (tail (cdr tags)) )
(let ( (xcld (delq head tail)) )
(begin
(display head) (newline)
(display tail) (newline)
(display xcld) (newline)
))))
(unique-var my-tags)Now examine the result carefully:
❯ guile 12-unique-b.scm
rock
(jazz rock pop pop)
(jazz pop pop)
Combine Guard and Head:Tail
Consider combine both codes.
(use-modules (oop goops))
(define my-tags (list
"rock" "jazz" "rock" "pop" "pop"))
(define-method
(unique-var (tags <list>))
(if
(<= (length tags) 1)
(tags)
(let
( (head (car tags)) (tail (cdr tags)) )
(let ( (xcld (delq head tail)) )
(begin
(display head) (newline)
(display tail) (newline)
(display xcld) (newline)
)))))
(unique-var my-tags)With the result exactly the same as previous code.
Recursive Unique Value
After head:tail, we can go further getting unique value.
(use-modules (oop goops))
(define my-tags (list
"rock" "jazz" "rock" "pop" "pop"))
(define-method
(unique (tags <list>))
(if
(<= (length tags) 1)
(begin
(display tags) (newline)
tags)
(let
( (head (car tags)) (tail (cdr tags)) )
(let
( (xcld (delq head tail)) )
(let
( (uniq (unique xcld)) )
(begin
(display (append (list head) uniq))
(newline)
(append (list head) uniq)
))))))
(unique my-tags)
(newline)Again, examine the result carefully:
❯ guile 12-unique-d.scm
()
(pop)
(jazz pop)
(rock jazz pop)
We already have our unique value. We need to clean up the subroutine.
10: Recursive Unique Function
Since we are going to reuse the unique approach in other script. It is better to bundle the script in its own guile module.
Clean Up
The cleaned-up version of previous code will be as below
(define my-tags (list
"rock" "jazz" "rock" "pop" "pop"))
(define (unique tags)
(if (<= (length tags) 1)
tags
(let
( (head (car tags)) (tail (cdr tags)) )
(append (list head)
(unique (delq head tail)))
)))
(display (string-join (unique my-tags) ":"))
(newline)The return values is a list.
(append (list head)
(unique (delq head tail)))With the result as below list.
❯ guile 13-unique-e.scm
rock:jazz:pop
Recursive Unique Function
Just like our previous flatten module, we can just copy paste the unique subroutine, into its own unique module.
(define-module (my-helper-unique))
(define-public (unique tags)
(if (<= (length tags) 1)
tags
(let
( (head (car tags)) (tail (cdr tags)) )
(append (list head)
(unique (delq head tail)))
)))
Using Unique Module
There is nothing to say in this code below.
Just apply unique function to our song records.
(add-to-load-path
(dirname (current-filename)))
(use-modules (my-helper-unique))
(define my-tags (list
"rock" "jazz" "rock" "pop" "pop"))
(display (string-join (unique my-tags) ":"))
(newline)With the result as below list:
❯ guile 13-unique-f.scm
rock:jazz:pop
Applying Unique to Songs Records
Now we can apply the method to our unique song challenge.
(add-to-load-path
(dirname (current-filename)))
(use-modules (my-songs))
(use-modules (my-helper-flatten))
(use-modules (my-helper-unique))
(display (string-join
(unique (flatten songs)) ":"))
(newline)With the same result as below
❯ guile 13-unique-g.scm
60s:jazz:rock:70s:popWe are done solving our challenge.
Style Guide
Forgive my indentation.
For those who care a lot about style, you can read this material below:
Summary
For convenience, I put all the code in just one screenshot figure as below:
This is the end of our guile journey in this article.
We shall meet again in other article.
What is Next 🤔?
Consider continue reading [ Racket - Playing with Records - Part One ].