מבוא לתכנות של קבוצת בטא/המדריך המהיר של עופר לשפת ג'וליה

מה זה זה?

זה מדריך לשפת התכנות ג'וליה שמוכוון לבטאים (חברי קבוצת בטא).
הכוונה לבטאים שסגרו 30 נקודות בC, כן? כאלו שמסתדרים עם מערכים ופויינטרים.

גם מי שלא חברי בטא יכולים ללמוד ממנו, אבל הם לא יכולים להתלונן ולקבל מעופר תשובות מתחכמות.
מי שיש לו שאלות, יש תשובות לא מתחכמות (טוב, קצת מתחכמות) בסעיף #שאלות ותשובות המהיר של עופר.

אבל יש פה המון טקסט, אין לי כוח לקרוא. התבכיינות התבכיינות.

רוצים פתרון קסם, נכון?

אין פתרון קסם. קראו את המדריך או שתלכו לשחק דוקים בבית.

אתגרים

כי במדריך המהיר של עופר תמיד יש איזה אתגר בהתחלה, נכון? אז הנה:

אתגר: אתגר ג'וליה! בצעו את כל אתגרי שפת C של בטא, רק בג'וליה! זה בלי נקודות, זה סתם כי בא לכם.

כבר טחנתם אותם בC ולא בא לכם?
טוב, אז אתגר אחר:

אתגר: אתגר ג'וליה אחר! היכנסו לcodewars, ועשו את כל האתגרים שם בג'וליה! גם זה בלי נקודות, לפחות עד שנגדיר אתגר codewars לג'וליה בויקיברסיטה של בטא. אבל תלמדו מזה המון. ותודו לי על זה כשתהיו נינג'ות.

קדימה לג'וליה.

למה ללמוד ג'וליה?

כי היא הולכת מתחזקת בתחום התכנות המדעי. וכי היא השפה המועדפת על בית ג'ין. וכי יש לי משחק בג'וליה שצריך שתוסיפו לו פיצ'רים, שאלו אותי כיצד.

למה ג'וליה ולא פייתון אם Rust או Go או שפה אחרת?

כי פייתון נורא איטית, Rust מתמחה בתכנות בטוח ולא מכוונת לתכנות מדעי או נומרי, וGo תפסה בעיקר בתחום הבק-אנד של הווב וזהו.
ג'וליה יותר בכיוון של להיות נוחה כמו פייתון, מהירה כמו C, ועוזרת לפתור שאלות מדעיות כמו שפות התכנות R או MATLAB רק בלי הזוועתון התכנותי של שתי השפות האלו. ובלי לבזבז כסף על רשיונות MATLAB. ויש שם כמה דברים מגניבים שעוד מעט תכירו ואין בשפות אחרות.

למה קוראים לזה ג'וליה?

כי זה שם יפה. זאת הסיבה הרשמית. הסיבה הלא רשמית היא "ככה".

שלום עולם!

בואו נתחיל עם תוכנת שלום עולם בג'וליה!

(אלא אם אתם תולים כביסה/שוטפים כלים ולא יכולים לשבת לקרוא. אז יש איזה סרטון שמסביר על תוכנת ג'וליה בסיסית. לחצו על "הצגה" שם משמאל לפרטים.)

כביסה/כלים זה תירוץ סביר.
אז קבלו: ישראל אונטרמן עשה סידרת סרטונים בעברית על פתרון אתגר פשוט בכמה שפות תכנות, וביניהם הוא עשה גם סרטון על ג'וליה. הוא מסביר יפה כמה יכולות בסיסיות של ג'וליה והמסקנה מעניינת (ותעצבן פייתוניסטים).

קדימה! איפה מקמפלים פה?

עם כל הכבוד לC תשכחו מקומפילציה ואז הרצה, העולם התקדם בזמן שקימפלתם.
ג'וליה היא לא שפה שבה כותבים קובץ קוד, מקמפלים לתוכנה ומריצים את התוכנה. בג'וליה כותבים את התוכנה ואז פשוט מריצים. הקומפילציה מתבצעת מעצמה בזמן ריצה. קימפול כזה נקרא קימפול JIT (קיצור של Just In Time), שהוא קימפול גמיש ומותאם לתוכנה. זה מרגיש כמו פייתון, רק מהיר יותר.

בעצם, לפעמים גם קובץ קוד זה יותר מדי בירוקרטיה. אפשר פשוט לכתוב קוד ולהריץ מיידית בREPL.

REPL? מה זה זה?

לג'וליה יש REPL, שזה המסך הזה שאפשר להריץ בו פקודות כדי לראות מה יוצא.
זה אומר שלא חייבים לכתוב תוכנה שלמה. ולהריץ, אפשר פשוט להריץ שורות קוד אחת אחת ואז להצטער שלא שמרנו מה שכתבנו (גם לזה כבר יש פתרון ששומר הכל, אבל זה לפעם אחרת). והREPL הזה מגיע עם האינטרפרטר של ג'וליה, מוכן לעבודה.

בשביל הניסויים שלנו נשתמש בREPL.

אז שלום עולם. צריך בשביל זה קומפיילר ג'וליה.

מאיפה משיגים קומפיילר לג'וליה?

windows

הכי קל: להביא מחנות האפליקציות של מייקרוסופט את Juliaup ולתת לו לנהל את ההתקנה והעידכונים.

פחות קל:
מהאתר של ג'וליה. יש לכם שם קישור צבעוני להורדה. אני אנחש שגירסת ה64bit installer זה מה שאתם רוצים.
אלא אם אתם על אחד מחמשת המחשבים העתיקים בכיתת בטא. אז אתם רוצים גירסת 32 ביט. ואלא אם יש לכם סיבה טובה לרצות שהוא ירוץ ללא התקנה, שאז אתם רוצים את גירסת הportable. אבל אין לכם סיבה טובה.

Linux

לא בדקתי עדיין. ספרו לי כשתבדקו.

חזרה לשלום עולם

התקנתם? בחרתם את האופציה שיכניס את ג'וליה לPATH? יופי. יאללה שלום עולם.

אתם מנסים כל מה שאני הולך לכתוב כאן, כן? בטטות לא אמורות להגיע לשלב הזה בבטא.

טוב.
נפתח את הREPL על ידי הרצה של התוכנה julia, ונראה דבר כזה, רק בצבעים יותר יפים:

               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.8.2 (2022-09-29)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

julia>

הנה ג'וליה מחכה שתגידו לה מה לעשות. נשאר רק להגיד שלום עולם. אז נכתוב לה כזה:

julia> "Hello World"

והיא תגיד:

Hello World

זהו. שלום עולם. אני הייתי אני.

הגזמת, מה זה השטות הזאת

טוב, ניצלתי כאן טריק מגעיל. אז נעשה את זה מסודר:

julia> print("Hello World")

ניסיתם? יופי, זה כותב אותו דבר.

עכשיו שתי שורות:

julia> print("Hello World"); print("foo")

זה לא כתב שתי שורות. אז תשתמשו בprintln, זה יוסיף ירידת שורה בקצה:

julia> println("Hello World"); println("foo")

שלום שתי שורות עולם.

לשאלתכם, כן, אפשר לכתוב גם:

julia> print("Hello World\n"); print("foo")

כמו ברברים. אבל זה לא C, צאו מזה.

ואיך כן כותבים תוכנה בשפה הזאת?

יוצרים קובץ עם הסיומת jl. שבו כותבים את הקוד (בדיוק כמו שכתבתם בREPL), ואז מריצים אותו. לדוגמה אם הקובץ הוא hello.jl, אז מריצים ככה:

julia hello.jl

ואיך יוצרים מזה קובץ exe?

לא יוצרים קובץ exe. מריצים בinterpreter..
או אם נדייק: יצרו כלים שיכולים להפוך את זה לexe, אבל זה למתקדמים, אז פעם אחרת.

ומה עם Jupyter Notebook?

מדענים מתים על מחברות אלקטרוניות. ככה הם לא שוכחים מה הם כתבו.
בשביל זה המציאו את Jupyter, שמתאים לג'וליה (לכן הJu) ולפייתון (ולכן הpy) ולעוד כמה שפות שהצטרפו אחר כך.
ולכן גם המציאו את Pluto.jl שזה כמו Jupyter אבל עובד קצת שונה.
יום אחד אני אכתוב פרק שלם עליהם, עד אז לכו לקרוא עליהם באינטרנט.

נקסט: בשביל לכתוב תוכנה צריך משתנים.
בואו נבין איך עובדים עם משתנים בג'וליה.

משתנים

נכנסתם לREPL, נכון? כי שם הכי קל לנסות דברים.

תנו לנו משתנים

ג'וליה היא שפה דינמית. לא חייבים להגדיר טיפוס למשתנים.

julia> a = 7
7

julia> a * 2
14

זהו. יש משתנה a עם הערך 7, ואפשר לשחק איתו.

אבל אנחנו רוצים משתנה בננה!

קבלו: ג'וליה משתמשת ביוניקוד לשמות משתנים, אז אפשר נגיד שיהיה לכם משתנה בננה:

julia>  🍌 = 3
3

julia> 🍌 + 🍌
6

בשביל לכתוב בננה, כותבים :banana:\, ואז לוחצים TAB. ככה אפשר לכתוב גם אותיות יווניות, סימנים ואימוג'ים. רשימה מלאה פה.

לא רואים אצלי בננה!

בואו נניח רגע שאתם בwindows, כי בלינוקס זה לא היה קורה.
יש מצב שהcmd שלכם מוגבל בעליל עם הפונטים העתיקים שלו, ולכן הREPL לא מצליח להראות בננות.
אתם צריכים את Windows Terminal. זו תוכנת קוד פתוח של מייקרוסופט שמשיגים מחנות האפליקציות שלהם ושעוקפת בהליכה אחורה את הCMD העתיק.
(או שמשתמשים בסקריפט להשיג אותה כי החנות של מייקרוסופט חסומה ושאר דברים כיפיים שקורים בחדר בטא.)
אחרי שהתקנתם, נסו להריץ מתפריט ההתחלה את התוכנה terminal, ושם להריץ את ג'וליה.
הופ, יש בננה.

איזה סוג של בננה זאת?

מאיזה סוג המשתנה בננה?

julia> typeof(🍌)
Int64

אז בעצם יש טיפוסים בשפה, פשוט ג'וליה יודעת לבד איזה טיפוס מתאים.

הנה עוד כמה טיפוסים:

julia> typeof(3)
Int64

julia> typeof(0.3)
Float64
 
julia> typeof(true)
Bool
 
julia> typeof("foo")
String
  
julia> typeof([1, 2, 3])
Vector{Int64} (alias for Array{Int64, 1})

לפעמים נרצה לקבוע את הטיפוס של המשתנה בעצמנו, זה יכול להאיץ את זמן הריצה.
אבל אם ננסה לעשות את זה למשתנה גלובלי, נקבל צעקות:

julia> 🍌::Int32 = 3
ERROR: TypeError: in typeassert, expected Int32, got a value of type Int64
Stacktrace:
 [1] top-level scope
   @ REPL[13]:1

כי מרגע שיש למשתנה גלובלי טיפוס, זה לנצח נצחים או עד שתסגרו את הprocess, מה שיבוא קודם.

אז לצורך ההדגמה וכדי לא להתחיל לסגור חלונות נשים את הבננה בצד ונעשה את זה עם משתנה סחוג בפיתה (:stuffed_flatbread:\):

julia> 🥙::Int32 = 3
3

סחוג בפיתה הוא עכשיו Int 32 ביט ויש בו את הערך 3. לא חשבתם שאי פעם תקראו את זה בספר ללימוד תכנות.

בכל מקרה, עדיף לעבוד עם משתנים מקומיים ולא עם גלובליים. זה גם יאיץ את זמן הריצה. גלובליים זה לפרופסורים עצלנים.
(אגב, טיפוסי משתנים גלובלי זה פיצ'ר חדש של ג'וליה 1.8.)

מה לשים בפיתה?

השמה למשתנים בג'וליה יכולה לבוא בצורות מעניינות.
יש לנו את הבסיסי:

julia> 🥙 = 3
3

יש שירשורים:

julia> 🥙 = 🍌 = 🐌 = 3
3

אפשר בקבוצות (יש לזה שם, שכחתי איך קוראים לזה):

julia> 🥙, 🍌 = 3, 5
(3, 5)
julia> 🍌
5

אפשר שההשמה תהיה סיפור קצר:

julia> 🥙 = (🍌 = 2; 🐌 = 3; 🐌 * 🍌)
6
julia> 🍌
2

אפשר גם לתת את הסיפור הזה בתוך בלוק, שיהיה יותר יפה:

julia> 🥙 = begin
                 🍌 = 2 
                 🐌 = 3 
                 🐌 * 🍌
             end
6
julia> 🥙
6

מה קרה? בקרה.

(גנבתי כאן המון קוד מהתיעוד הרשמי של ג'וליה, שהם שחררו תחת רשיון MIT, כפרה עליהם.)

הנה רצף התנאים והלולאות שכל אחד צריך בפאוץ' הכלים שלו. קחו נשימה עמוקה, אין סוגריים מסולסלים:

תנאים

if x < y
    println("x is less than y")
elseif x > y
    println("x is greater than y")
else
    println("x is equal to y")
end

לולאות

לולאת while

i = 1;

while i <= 5
    println(i)
    global i += 1
end

1
2
3
4
5

לולאת for

for i = 1:5
    println(i)
end

1
2
3
4
5

list comprehension

כן, יש בג'וליה list comprehension כדי שתוכלו לדחוס קוד ולטעון שזה יותר יפה ככה:

[x*3 for x in 1:3]

3-element Vector{Int64}:
 3
 6
 9

try catch

יגיע בהמשץ'

פונקציות

כותבים function בהתחלה, ויש לכם פונקציה. אפשר טיפוס של ערך מוחזר, אפשר פרמטרים, אפשר טיפוסים לפרמטרים, לא חובה.

אגב, כבר סיפרתי שכוכביות משמשות בג'וליה להדבקת strings? אז כן. עכשיו תבינו את הפונקציה:

julia> function hello(foo, bar)
           println(foo *", "* bar *"!")
       end

hello (generic function with 1 method)

רואים את כל קשקוש הfunctions methods הזה? זה קונספט די חשוב בג'וליה. פרטים בדף ה/פיצפוצים#מלטיפל דיספאץ'/. ולעניין: זאת היתה פונקציה חביבה, שני פרמטרים, ללא טיפוס מוחזר, ללא טיפוסי פרמטרים, סקריפטיאדה כזה.

וככה מפעילים את הפונקציה, שוב, לא משהו מהפכני:

julia> hello("hi", "world")

hi, world!

איזה טיפוסים

כמובן שהיה יעיל יותר אם הייתם מציינים את הטיפוסים של הפרמטרים, ככה שהקומפיילר של ג'וליה יוכל לנחש יותר טוב איך נכון לבנות את התוכנה:

julia> function hello(foo::String, bar::String)
           println(foo *", "* bar *"!")
       end

אבל כמו שאמרנו, זה לא חובה. למעשה בפונקציה הזאת הקוד עצמו מרמז שאלו strings, ועדיין עצם ציון הטיפוסים הפך את הקוד למהיר יותר בממוצע בכל הבדיקות שעשיתי.

איזה טיפוס גם הערך המוחזר

-- צריך לכתוב את החלק הזה ---

איזה לא טיפוס הערך המוחזר

לא באמת חייבים להחזיר משהו.

-- אלא אם יש הגדרת טיפוס? להשלים. --

פונקציות הן אזרחים סוג א'!

בג'וליה ניתן להעביר פונקציה כפרמטר. זה לא יפתיע חובבי Lisp.

function sqofsq(func, num)
    func(func(num))
end

sqofsq (generic function with 1 method)

משמע, בג'וליה פונקציות הן first class citizens, ולא איזה יצור מיוחד ומוזר וסוג ב'. פונקציה זה פשוט ערך שאפשר לתת למשתנה.

פונקציות אנונימיות

יש בקהל חובבי תכנות פונקציונלי? יופי, קבלו פונקציות אנונימיות. (ושימו לב שעברנו לstate חובבי תכנות פונקציונלי, רק אומר).

julia> a = x -> x * 2

#1 (generic function with 1 method)

ככה. הגדרתי פונקציה על המקום, בלי שם, עם פרמטר x, וזרקתי אותה למשתנה. אז עכשיו המשתנה מייצג את הפונקציה, ויכול להריץ אותה:

julia> a(3)

6

קומפוזיציה, לאופולד

אפשר לעשות לפונקציות קומפוזיציה. לא הלחנה, קומפוזיציה של מתימטיקה, כזו שמלבישה פונקציה אחת על פונקציה אחרת ונוצרת פונקציה אחת גדולה ומנופחת.

f(x) = 3x
g(x) = x - 3
h = f ∘ g

את ה∘ כותבים circ\ ואז טאב (בREPL).

אז מה תעשה פונקציה h למען השם?
היא תעשה f(g(x)).
שזה בדיוק כאילו כתבנו:

h = 3(x-3)

רק תוך כדי שימוש ביכולות שכבר קיימות, כי מתכנת טוב הוא מתכנת קצת עצלן. קצת. (וכי זה נותן לנו יכולת להרכיב פונקציות הרבה יותר מורכבות, כולל כאלו שלא כתבנו בעצמנו.)

הו, איזה אופרטור קטן וחביב ה∘ הזה, בטח אין עוד שום דבר לדעת עליו

אז זהו שכרגיל, בוגומיוו קמינסקי עושה לנו בית ספר גם על ∘. לכו לקרוא, האיש אשף.

תחמושת בסיסית לREPL

חוץ מלתת לנו לכתוב קוד ג'וליה הREPL בג'וליה יודע לעשות עוד הרבה דברים. המון דברים.
אבל בתור התחלה בואו נלמד שלושה מצבים של הREPL שמאפשרים לעשות דברים מעניינים:

• התקנת חבילות
• קריאת תיעוד
• גישה לטרמינל

אבל נתחיל מאיך יוצאים מהמצבים האלו: לוחצים על backspace. שלא תגידו שלא אמרתי. זה קל, זה לא vi פה.

התקנת חבילות

אין לנו סיבה להתקין חבילות. אז בואו ניתן לעצמנו סיבה!

צרו לעצמכם struct והגדירו בעזרתו משתנה:

struct st1
    a::Int32
    b::Float32
end

foo = st1(2, 3.4)

אם אנחנו מדפיסים אותו:

julia> print(foo)

זה יראה ככה

st1(2, 3.4f0)

בסיסי משהו. בואו נשתמש בפונקציה pprint שנותנת הדפסה מועילה יותר. אבל היא לא חלק מהשפה. היא נמצאת בחבילה PrettyPrint. אז נשתמש בחבילה PrettyPrint:

julia> using PrettyPrint

 │ Package PrettyPrint not found, but a package named PrettyPrint is available from a registry.
 │ Install package?
 │   (@v1.8) pkg> add PrettyPrint
 └ (y/n/o) [y]:

תראו מה זה. אין לנו את החבילה, אז ג'וליה מציעה להתקין את החבילה. חמודה.
אם נגיד לה y ג'וליה תתקין את החבילה ואז נוכל לראות הדפסה יפה יותר:

julia> pprint(foo)

st1(a=2, b=3.4f0)

איזה יופי. צהלה שמחה וגיל.

אבל פעם ג'וליה לא היתה כזאת נחמדה ומציעה להתקין, והיה צריך להתקין דרך מנהל החבילות שלה. וגם אם כיום רוצים להסיר חבילה, לבדוק אם היא קיימת, או שאר ירקות, צריך להשתמש במנהל החבילות. אז נלמד פקודה או שתיים שלו.

איך נכנסים למנהל החבילות?

בREPL כותבים [ ואז תראו את זה:

(@v1.8) pkg>

זה מנהל החבילות. היי. אז מה הוא יודע לעשות?

הסרה במנהל החבילות

נסיר, למשל, את PrettyPrint:

(@v1.8) pkg> rm PrettyPrint

    Updating `C:\Users\oferw\.julia\environments\v1.8\Project.toml`
  [8162dcfd] - PrettyPrint v0.2.0
    Updating `C:\Users\oferw\.julia\environments\v1.8\Manifest.toml`
  [8162dcfd] - PrettyPrint v0.2.0
[ Info: We haven't cleaned this depot up for a bit, running Pkg.gc()...
      Active manifest files: 8 found
      Active artifact files: 99 found
      Active scratchspaces: 3 found
     Deleted 18 package installations (83.097 MiB)
     Deleted 11 artifact installations (77.576 MiB)
     Deleted 2 scratchspaces (397.000 byte)

התקנה במנהל החבילות

ונתקין שוב את PrettyPrint, רק כדי שתדעו איך:

(@v1.8) pkg> add PrettyPrint

   Resolving package versions...
    Updating `C:\Users\oferw\.julia\environments\v1.8\Project.toml`
  [8162dcfd] + PrettyPrint v0.2.0
    Updating `C:\Users\oferw\.julia\environments\v1.8\Manifest.toml`
  [8162dcfd] + PrettyPrint v0.2.0

ממש קצת הדפסות היו שם, נראה שהוא לא מחק כמעט כלום. זה בגלל שהסרה של החבילה לא באמת מוחקת אותה מהחשב, רק מנתקת אותה.
אם רוצים למחוק לגמרי זה קצת יותר כאב ראש, אז נשאיר את זה לפעם אחרת.

רגע, הצילו, איך יוצאים בחזרה ממנהל החלונות לג'וליה?

לוחצים על backspace. זה כתוב למעלה, קראתם, נכון?

קריאת תיעוד

נגיד שאין לנו מושג מה עושה ()pprint. אז בREPL כותבים סימן שאלה, והוא נכנס למצב עזרה:

help?>

ואז פשוט כותבים את הפונקציה שרוצים עזרה עליה:

help?> pprint

search: pprint pprintln PrettyPrint

  pretty print to IO.

שזה הסבר קטן ונחמד. או בסיסי ולא מספק, תלוי מה אתם מחפשים. תבדקו את התיעוד של print, הוא קצת יותר רציני.

ואפשר למצוא תיעוד קולע כזה בערך לכל דבר. נגיד for, או if או try.
ואם לא בטוחים, פשוט רושמים חלק מהמילה, וג'וליה תציע לכם את כל התיעודים שמכילים את החלק שכתבתם:

help?> t

search: try tan time tanh tand Text tuple throw Type Task trunc trues touch take! typeof Tuple Timer typemin typemax

Couldn't find t
Perhaps you meant !, %, &, ', *, +, -, /, :, <, >, \, ^, |, ~, ÷, π, ℯ, ∈, ∉, ∋, ∌, ∘, √, ∛, ∩, ∪, ≈, ≉, ≠, ≡, ≢, ≤ or ≥
  No documentation found.

  Binding t does not exist.

אז אנחנו יודעים לקבל עזרה.
ועכשיו נלמד איך לקבל גישה לטרמינל מחמל נפשנו בלי להוריד ידיים מהמקלדת, כי זה מה שבטאים עושים.

גישה לshell

הshell זה מה שאתם כותבים בו פקודות כשאתם בטרמינל. המסך השחור הוא הטרמינל, הדבר שאתם כותבים לו פקודות זה הshell. זה כתוב במדריך המהיר ללינוקס, אני לא מסביר את זה שוב.

לגישה לטרמינל בREPL של ג'וליה, כתבו בREPL פסיקודה ; ותקבלו את זה:

shell>

כאן אפשר לכתוב את פקודות הטרמינל הרגילות שלכם!
אלא אם אתם בWindows, שם הוא לא יקבל שום פקודה. כי בWindows כיף כיף כיף. כי windows הוא חתול והפקודות שלכם מעניינות אותו כשלג דאשתקד.

אז איך מגיעים לshell בwindows?

כותבים powershell וכל הפונט משתנה וכל הפקודות שלכם פתאום יעבדו. כי כשממש רוצים, חתול יתעניין בשלג דאשתקד.
כתבו exit כדי לצאת משם.

להיות יבואן רשמי

אז למדנו שמייבאים חבילות עם using:

julia> using PrettyPrint

שזה מביא את כל הפונקציות והמשתנים הגלובליים של PrettyPrint אל מרחב השמות של התוכנה שלי. יופי.
אז נתחיל סשן ג'וליה נקי, נכתוב לנו פונקציה קטנה ואז נשתמש בפונקציה ()pprint כדי להדפיס יפה:

julia> function is_simple(a)
           println("my simple!")
       end

is_simple (generic function with 1 method)

נבדוק שהיא עובדת:

julia> is_simple(3)

my simple!

אחלה, עובדת. נייבא את PrettyPrint כדי שיהיו לנו הדפסות יפות:

julia> using PrettyPrint

WARNING: using PrettyPrint.is_simple in module Main conflicts with an existing identifier.

אוי, השם ירחם. גם לPrettyPrint יש ()is_simple. לפחות ג'וליה מודיעה שיש התנגשות ולא ממשיכה בסבבה לירות לנו ברגל.
אבל זאת רק אזהרה, אז PrettyPrint כן יובאה, והשאלה היא איזה פונקציית is_simple תרוץ עכשיו, שלי או של PrettyPrint?
נבדוק:

julia> is_simple(3)

my simple!

זאת הפונקציה שלי.

אבל רגע, אני בכלל רציתי רק את pprint, למה אני צריך את כל שאר הדברים שPrettyPrint שופכת עלי?

שאלה מצוינת. בשביל זה יש את import שמייבאת רק את מה שמבקשים ממנה:

julia> import PrettyPrint: pprint

וזהו, אין אזהרות, אין התנגשויות, הבאנו רק את pprint, ואפשר להשתמש בה בדיוק כמו שעשינו עם using. נקי, אלגנטי, אלמנטרי ווטסון.

טוב, הבנו את הבסיס. מה עכשיו

עכשיו פיצפוצים.

שאלות ותשובות המהיר של עופר

לא שאלתם שאלות, אז אין.